tomwer 1.1.0rc7__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/io/utils/utils.py

@@ -31,15 +31,17 @@ __license__ = "MIT"
 __date__ = "07/09/2020"
 
 
-import numpy.lib.npyio
+import logging
 import os
+
+import h5py
+import numpy.lib.npyio
+from PIL import Image
+from tomoscan.esrf import has_glymur
 from tomoscan.esrf.scan.utils import get_data as tomoscan_get_data
 from tomoscan.io import HDF5File
+
 from tomwer.core.utils import ftseriesutils
-from PIL import Image
-import logging
-import h5py
-from tomoscan.esrf import has_glymur
 
 try:
     import tifffile  # noqa #F401 needed for later possible lazy loading
@@ -106,47 +108,41 @@ def _loadVol(url):
 
     if not os.path.exists(rawFile):
         data = None
-        mess = "Can't find raw data file %s associated with %s" % (rawFile, infoFile)
+        mess = f"Can't find raw data file {rawFile} associated with {infoFile}"
         _logger.warning(mess)
     elif not os.path.exists(infoFile):
-        mess = "Can't find info file %s associated with %s" % (infoFile, rawFile)
+        mess = f"Can't find info file {infoFile} associated with {rawFile}"
         _logger.warning(mess)
         data = None
     else:
         shape = ftseriesutils.get_vol_file_shape(infoFile)
         if None in shape:
-            _logger.warning("Fail to retrieve data shape for %s." % infoFile)
+            _logger.warning(f"Fail to retrieve data shape for {infoFile}.")
             data = None
         else:
             try:
                 numpy.zeros(shape)
             except MemoryError:
                 data = None
-                _logger.warning(
-                    "Raw file %s is to large for being " "readed %s" % rawFile
-                )
+                _logger.warning(f"Raw file {rawFile} is to large for being readed")
             else:
                 data = numpy.fromfile(rawFile, dtype=numpy.float32, count=-1, sep="")
                 try:
                     data = data.reshape(shape)
                 except ValueError:
                     _logger.warning(
-                        "unable to fix shape for raw file %s. "
-                        "Look for information in %s"
-                        "" % (rawFile, infoFile)
+                        f"unable to fix shape for raw file {rawFile}. Look for information in {infoFile}"
                     )
                     try:
                         sqr = int(numpy.sqrt(len(data)))
                         shape = (1, sqr, sqr)
                         data = data.reshape(shape)
                     except ValueError:
-                        _logger.info("deduction of shape size for %s failed" % rawFile)
+                        _logger.info(f"deduction of shape size for {rawFile} failed")
                         data = None
                     else:
                         _logger.warning(
-                            "try deducing shape size for %s "
-                            "might be an incorrect "
-                            "interpretation" % rawFile
+                            f"try deducing shape size for {rawFile} might be an incorrect interpretation"
                         )
     if url.data_slice() is None:
         return data
@@ -179,9 +175,9 @@ def format_stderr_stdout(stdout, stderr, config=None):
     else:
         assert isinstance(config, dict)
     return (
-        "############# nabu ############## \nconfig: {}\n"
-        "------------- stderr -------------\n{}\n"
-        "------------- stdout -------------\n{}\n".format(config, s_err, s_out)
+        f"############# nabu ############## \nconfig: {config}\n"
+        f"------------- stderr -------------\n{s_err}\n"
+        f"------------- stdout -------------\n{s_out}\n"
     )
 
 

tomwer/resources/__init__.py

@@ -24,8 +24,8 @@
 # ###########################################################################*/
 
 
-import os
 import importlib
+import os
 import sys
 
 # pkg_resources is useful when this package is stored in a zip

tomwer/synctools/axis.py

@@ -27,9 +27,11 @@ __license__ = "MIT"
 __date__ = "03/05/2019"
 
 
+import logging
+
 from silx.gui import qt
+
 from tomwer.core.process.reconstruction.axis.params import AxisRP
-import logging
 
 logger = logging.getLogger(__name__)
 

tomwer/synctools/darkref.py

@@ -27,10 +27,11 @@ __license__ = "MIT"
 __date__ = "03/05/2019"
 
 
+import logging
+
 from silx.gui import qt
-from tomwer.core.process.reconstruction.darkref import params as dkrf
 
-import logging
+from tomwer.core.process.reconstruction.darkref import params as dkrf
 
 logger = logging.getLogger(__name__)
 

tomwer/synctools/datalistener.py

@@ -28,16 +28,20 @@ __license__ = "MIT"
 __date__ = "16/03/2020"
 
 
-from tomwer.core.process.control.datalistener.rpcserver import _BaseDataListenerThread
-from tomwer.core.process.control.datalistener.rpcserver import BlissAcquisition
-from tomwer.core.process.control.datalistener.rpcserver import TangoAcquisitionStatus
+import logging
+import time
 from collections import namedtuple
 from datetime import datetime
+from multiprocessing import Lock, Manager
+
 from silx.gui import qt
+
+from tomwer.core.process.control.datalistener.rpcserver import (
+    BlissAcquisition,
+    TangoAcquisitionStatus,
+    _BaseDataListenerThread,
+)
 from tomwer.utils import docstring
-import time
-from multiprocessing import Manager, Lock
-import logging
 
 _logger = logging.getLogger(__name__)
 

tomwer/synctools/datatransfert.py

@@ -29,9 +29,8 @@ __date__ = "28/01/2019"
 
 
 from silx.gui import qt
-from tomwer.core.process.control.scantransfer import (
-    ScanTransfer as FolderTransfertP,
-)
+
+from tomwer.core.process.control.scantransfer import ScanTransfer as FolderTransfertP
 from tomwer.core.scan.scanbase import TomwerScanBase
 
 

tomwer/synctools/imageloaderthread.py

@@ -28,11 +28,13 @@ __author__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "02/06/2017"
 
-from silx.gui import qt
-import numpy.lib.npyio
+import logging
 import os
+
+import numpy.lib.npyio
+from silx.gui import qt
+
 import tomwer.resources
-import logging
 from tomwer.io.utils import get_slice_data
 
 logger = logging.getLogger(__name__)

tomwer/synctools/rsyncmanager.py

@@ -31,10 +31,11 @@ __license__ = "MIT"
 __date__ = "11/04/2017"
 
 
-from rsyncmanager import RSyncManager
+import logging
 import time
+
+from rsyncmanager import RSyncManager
 from silx.gui import qt
-import logging
 
 logger = logging.getLogger(__name__)
 

tomwer/synctools/saaxis.py

@@ -27,9 +27,11 @@ __license__ = "MIT"
 __date__ = "03/05/2019"
 
 
+import logging
+
 from silx.gui import qt
+
 from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-import logging
 
 logger = logging.getLogger(__name__)
 

tomwer/synctools/sadeltabeta.py

@@ -27,9 +27,11 @@ __license__ = "MIT"
 __date__ = "20/05/2021"
 
 
+import logging
+
 from silx.gui import qt
+
 from tomwer.core.process.reconstruction.sadeltabeta.params import SADeltaBetaParams
-import logging
 
 logger = logging.getLogger(__name__)
 

tomwer/synctools/stacks/control/datalistener.py

@@ -28,15 +28,18 @@ __date__ = "16/11/2020"
 
 
 from silx.gui import qt
+
 from tomwer.core.process.control.datalistener import DataListener
-from ..processingstack import FIFO, ProcessingThread
 from tomwer.core.scan.blissscan import BlissScan
 
+from ..processingstack import FIFO, ProcessingThread
+
 try:
     # new HDF5Config class
     from nxtomomill.io.config import TomoHDF5Config as HDF5Config
 except ImportError:
     from nxtomomill.io.config import HDF5Config
+
 import logging
 
 _logger = logging.getLogger(__name__)
@@ -54,7 +57,7 @@ class DataListenerProcessStack(FIFO, qt.QObject):
     def _process(self, data, configuration, callback=None):
         assert isinstance(data, BlissScan)
         assert isinstance(configuration, HDF5Config)
-        _logger.info("DataListenerProcessStack is processing {}".format(str(data)))
+        _logger.info(f"DataListenerProcessStack is processing {data}")
         self._data_currently_computed = data
         self._computationThread.finished.connect(self._end_threaded_computation)
 
@@ -105,18 +108,14 @@ class _DataListenerConverterThread(ProcessingThread):
 
     def init(self, data, configuration):
         if not isinstance(data, BlissScan):
-            raise TypeError(
-                "Only manage BlissScan. {} is not managed" "".format(type(data))
-            )
+            raise TypeError(f"Only manage BlissScan. {type(data)} is not managed")
         assert isinstance(configuration, HDF5Config)
         self._scan = data
         self._configuration = configuration
 
     def run(self):
         self.sigComputationStarted.emit()
-        _logger.processStarted(
-            "Start conversion of bliss scan {}".format(str(self._scan))
-        )
+        _logger.processStarted(f"Start conversion of bliss scan {self._scan}")
 
         data_listener = DataListener()
         data_listener.set_configuration(self._configuration or {})
@@ -129,11 +128,9 @@ class _DataListenerConverterThread(ProcessingThread):
             )
         except Exception as e:
             _logger.processFailed(
-                "Conversion of bliss scan {}." "Reason is {}".format(str(self._scan), e)
+                f"Conversion of bliss scan {self._scan}. Reason is {e}"
             )
             scans = None
         else:
-            _logger.processSucceed(
-                "Conversion of bliss scan {}." "".format(str(self._scan))
-            )
+            _logger.processSucceed(f"Conversion of bliss scan {self._scan}.")
         self.parent().register_result(self._scan, scans)

tomwer/synctools/stacks/edit/darkflatpatch.py

@@ -27,17 +27,20 @@ __license__ = "MIT"
 __date__ = "28/08/2020"
 
 
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
 from silx.gui import qt
-from tomwer.core.scan.scanbase import TomwerScanBase
+from silx.io.url import DataUrl
+
+from tomwer.core.process.edit import darkflatpatch
 from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
+
 from ..processingstack import FIFO, ProcessingThread
-from tomwer.core.process.edit import darkflatpatch
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import ProcessManager, DatasetState
-from silx.io.url import DataUrl
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -52,7 +55,7 @@ class DarkFlatPatchProcessStack(FIFO, qt.QObject):
         self._dry_run = False
 
     def _process(self, data, configuration, callback=None):
-        _logger.info("dark-flat patch stack is processing {}".format(str(data)))
+        _logger.info(f"dark-flat patch stack is processing {data}")
         self._data_currently_computed = data
         assert isinstance(data, TomwerScanBase)
         self._computationThread.finished.connect(self._end_threaded_computation)
@@ -107,15 +110,13 @@ class _DarkFlatPatchProcessingThread(ProcessingThread, SuperviseProcess):
 
     def run(self):
         self.sigComputationStarted.emit()
-        _logger.processStarted("{} Start dark-flat patch".format(str(self._scan)))
+        _logger.processStarted(f"{self._scan} Start dark-flat patch")
         try:
             darkflatpatch.apply_dark_flat_patch(
                 config=self._configuration, scan=self._scan
             )
         except Exception as e:
-            info = "Fail to patch dark-flat for {}. Reason is " "{}".format(
-                str(self._scan), e
-            )
+            info = f"Fail to patch dark-flat for {self._scan}. Reason is {e}"
             _logger.processFailed(info)
             ProcessManager().notify_dataset_state(
                 dataset=self._scan,
@@ -148,7 +149,7 @@ class _DarkFlatPatchProcessingThread(ProcessingThread, SuperviseProcess):
                 _logger.warning(
                     f"Fail to register DarkFlatPatch process. Reason is {e}"
                 )
-            info = "Dark-flat patched for {}." "".format(str(self._scan))
+            info = f"Dark-flat patched for {self._scan}."
             _logger.processSucceed(info)
             ProcessManager().notify_dataset_state(
                 dataset=self._scan,

tomwer/synctools/stacks/edit/imagekeyeditor.py

@@ -27,16 +27,19 @@ __license__ = "MIT"
 __date__ = "28/08/2020"
 
 
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
 from silx.gui import qt
+from tomoscan.esrf.scan.hdf5scan import ImageKey
+
+from tomwer.core.process.edit import imagekeyeditor
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
+
 from ..processingstack import FIFO, ProcessingThread
-from tomwer.core.process.edit import imagekeyeditor
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import ProcessManager, DatasetState
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -50,14 +53,14 @@ class ImageKeyEditorProcessStack(FIFO, qt.QObject):
         self._dry_run = False
 
     def _process(self, data, configuration, callback=None):
-        _logger.info("image-key edition is processing {}".format(str(data)))
+        _logger.info(f"image-key edition is processing {data}")
         self._data_currently_computed = data
         assert isinstance(data, TomwerScanBase)
         self._computationThread.finished.connect(self._end_threaded_computation)
 
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
-            mess = "low memory, skip image-key-edition for", data.path
+            mess = f"low memory, skip image-key-edition for {data.path}"
             _logger.processSkipped(mess)
             ProcessManager().notify_dataset_state(
                 dataset=data,
@@ -103,15 +106,13 @@ class _ImageKeyEditorProcessingThread(ProcessingThread, SuperviseProcess):
 
     def run(self):
         self.sigComputationStarted.emit()
-        _logger.processStarted("Start image key edition of {}".format(str(self._scan)))
+        _logger.processStarted(f"Start image key edition of {self._scan}")
         try:
             imagekeyeditor.change_image_key_control(
                 config=self._configuration, scan=self._scan
             )
         except Exception as e:
-            info = "Fail to edit image keys for {}. Reason is {}".format(
-                str(self._scan), e
-            )
+            info = f"Fail to edit image keys for {self._scan}. Reason is {e}"
             _logger.processFailed(info)
             ProcessManager().notify_dataset_state(
                 dataset=self._scan,

tomwer/synctools/stacks/processingstack.py

@@ -29,9 +29,10 @@ __date__ = "08/01/2020"
 
 
 from queue import Queue
-from silx.gui import qt
-from processview.core.manager import ProcessManager, DatasetState
+
+from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
 
 
 class ProcessingThread(qt.QThread):

tomwer/synctools/stacks/reconstruction/axis.py

@@ -27,21 +27,23 @@ __license__ = "MIT"
 __date__ = "03/05/2019"
 
 
+import functools
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
 from tomwer.core.process.reconstruction.axis import AxisProcess
 from tomwer.core.process.reconstruction.axis.axis import NoAxisUrl
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from processview.core.manager import ProcessManager
-from tomwer.synctools.axis import QAxisRP
-from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
-from processview.core.manager import DatasetState
+from tomwer.synctools.axis import QAxisRP
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from silx.gui import qt
-import logging
-import functools
 
 _logger = logging.getLogger(__name__)
 
@@ -115,15 +117,13 @@ class AxisProcessStack(FIFO, qt.QObject):
             not self._axis_params.use_sinogram
             and mode not in AxisProcess._CALCULATIONS_METHODS
         ):
-            _logger.warning("no method defined to compute {}".format(mode))
+            _logger.warning(f"no method defined to compute {mode}")
             if callback is not None:
                 callback()
             self._process_next()
         else:
             _logger.processStarted(
-                "Start cor calculation on {} ({})".format(
-                    str(data), self._axis_params.get_simple_str()
-                )
+                f"Start cor calculation on {data} ({self._axis_params.get_simple_str()})"
             )
             data.axis_params.set_relative_value("...")
             self._axis_params.set_relative_value("...")

tomwer/synctools/stacks/reconstruction/castvolume.py

@@ -27,6 +27,13 @@ __license__ = "MIT"
 __date__ = "15/21/2021"
 
 
+import functools
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
 from tomwer.core.process.reconstruction.nabu.castvolume import CastVolumeTask
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
@@ -34,12 +41,8 @@ from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.utils import isLowOnMemory
 from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.volume.volumefactory import VolumeFactory
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import ProcessManager, DatasetState
-from silx.gui import qt
-import logging
-import functools
 
 _logger = logging.getLogger(__name__)
 

tomwer/synctools/stacks/reconstruction/dkrefcopy.py

@@ -26,20 +26,21 @@ __authors__ = ["H.Payno"]
 __license__ = "MIT"
 __date__ = "13/08/2021"
 
+import functools
+import logging
 import shutil
+import tempfile
 
-from processview.core.manager import ProcessManager
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
+from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
-from processview.core.manager import DatasetState
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
-from silx.gui import qt
-import logging
-import functools
-import tempfile
 
 _logger = logging.getLogger(__name__)
 
@@ -76,7 +77,7 @@ class DarkRefCopyProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("dk-ref-copy {}" "".format(str(data)))
+        _logger.processStarted(f"dk-ref-copy {data}")
         assert isinstance(data, TomwerScanBase)
         self._data_currently_computed = data
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:

tomwer/synctools/stacks/reconstruction/lamino.py

@@ -30,13 +30,15 @@ __license__ = "MIT"
 __date__ = "01/10/2018"
 
 
-from queue import Queue
-from silx.gui import qt
+import copy
 import logging
-from tomwer.core.scan.scanbase import TomwerScanBase
+from queue import Queue
+
 from processview.core.superviseprocess import SuperviseProcess
-import copy
+from silx.gui import qt
+
 from tomwer.core.process.reconstruction.lamino.tofu import LaminoReconstruction
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.Singleton import singleton
 
 logger = logging.getLogger(__name__)
@@ -122,7 +124,7 @@ class LaminoReconstructionStack(qt.QObject, Queue):
             callback,
         ) = Queue.get(self)
         self.sigReconsStarted.emit(scan)
-        info = "start lamino reconstuction of {}".format(str(scan))
+        info = f"start lamino reconstuction of {scan}"
         logger.processStarted(info)
         self.reconsThread.init(
             recons_obj=recons_obj,
@@ -147,7 +149,7 @@ class LaminoReconstructionStack(qt.QObject, Queue):
 
     def _dealWithFinishedRecons(self, scan):
         assert isinstance(scan, TomwerScanBase)
-        info = "lamino reconstruction of {} finished".format(str(scan))
+        info = f"lamino reconstruction of {scan} finished"
         logger.processSucceed(info)
         self.sigReconsFinished.emit(scan)
         self.execNext()
@@ -159,7 +161,7 @@ class LaminoReconstructionStack(qt.QObject, Queue):
 
     def _dealWithFailedRecons(self, scan):
         assert isinstance(scan, TomwerScanBase)
-        info = "reconstruction of {} failed".format(str(scan))
+        info = f"reconstruction of {scan} failed"
         logger.processFailed(info)
         self.sigReconsFailed.emit(scan)
         self.execNext()