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

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()

tomwer/synctools/stacks/reconstruction/nabu.py

@@ -27,18 +27,21 @@ __license__ = "MIT"
 __date__ = "28/08/2020"
 
 
+import gc
+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 tomwer.core.scan.edfscan import EDFTomoScan
+
 from tomwer.core.process.reconstruction.nabu import nabuslices, nabuvolume
+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 tomwer.io.utils import format_stderr_stdout
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import ProcessManager, DatasetState
-import gc
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -53,7 +56,7 @@ class NabuSliceProcessStack(FIFO, qt.QObject):
         self._dry_run = False
 
     def _process(self, data, configuration, callback=None):
-        _logger.info("Nabu slice stack is processing {}".format(str(data)))
+        _logger.info(f"Nabu slice stack is processing {data}")
         ProcessManager().notify_dataset_state(
             dataset=data,
             process=self,
@@ -66,7 +69,7 @@ class NabuSliceProcessStack(FIFO, qt.QObject):
 
         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 nabu reconstruction for", data.path
+            mess = f"low memory, skip nabu reconstruction for {data.path}"
             _logger.processSkipped(mess)
             ProcessManager().notify_dataset_state(
                 dataset=data,
@@ -128,7 +131,7 @@ class _SliceProcessingThread(ProcessingThread, SuperviseProcess):
 
     def run(self):
         self.sigComputationStarted.emit()
-        mess = "Start nabu slice(s) reconstruction of {}".format(str(self._scan))
+        mess = f"Start nabu slice(s) reconstruction of {self._scan}"
         _logger.processStarted(mess)
         ProcessManager().notify_dataset_state(
             dataset=self._scan,
@@ -187,12 +190,12 @@ class _SliceProcessingThread(ProcessingThread, SuperviseProcess):
 
             # TODO: check output files with the tomoscan validator ?
             if not succeed:
-                mess = "Slices computation for {} failed.".format(str(self._scan))
+                mess = f"Slices computation for {self._scan} failed."
                 state = DatasetState.FAILED
                 _logger.processFailed(mess)
             else:
                 state = DatasetState.SUCCEED
-                mess = "Slices computed for {}.".format(str(self._scan))
+                mess = f"Slices computed for {self._scan}."
                 _logger.processSucceed(mess)
             elmts = [
                 format_stderr_stdout(stderr=stderr, stdout=stdout)
@@ -216,7 +219,7 @@ class _VolumeProcessingThread(_SliceProcessingThread):
 
     def run(self):
         self.sigComputationStarted.emit()
-        mess = "Start nabu volume reconstruction of {}".format(str(self._scan))
+        mess = f"Start nabu volume reconstruction of {self._scan}"
         _logger.processStarted(mess)
         ProcessManager().notify_dataset_state(
             dataset=self._scan,
@@ -241,9 +244,7 @@ class _VolumeProcessingThread(_SliceProcessingThread):
             )
         except Exception as e:
             self._future_tomo_obj = None
-            mess = "Fail to compute volume for {}. Reason is {}".format(
-                str(self._scan), e
-            )
+            mess = f"Fail to compute volume for {e}. Reason is {e}"
             _logger.processFailed(mess)
             ProcessManager().notify_dataset_state(
                 dataset=self._scan,
@@ -276,11 +277,11 @@ class _VolumeProcessingThread(_SliceProcessingThread):
             ]
 
             if not succeed:
-                mess = "Volume computed for {} failed.".format(str(self._scan))
+                mess = f"Volume computed for {self._scan} failed."
                 _logger.processFailed(mess)
                 state = DatasetState.FAILED
             else:
-                mess = "Volume computed for {}.".format(str(self._scan))
+                mess = f"Volume computed for {self._scan}."
                 _logger.processSucceed(mess)
                 state = DatasetState.SUCCEED
 

tomwer/synctools/stacks/reconstruction/normalization.py

@@ -27,19 +27,19 @@ __license__ = "MIT"
 __date__ = "19/07/2021"
 
 
-from tomwer.core.process.reconstruction.normalization import (
-    SinoNormalizationTask,
-)
-from processview.core.manager import ProcessManager
+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.normalization import SinoNormalizationTask
 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 silx.gui import qt
-import functools
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -58,7 +58,7 @@ class INormalizationProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("start intensity normalization {}".format(str(data)))
+        _logger.processStarted(f"start intensity normalization {data}")
         assert isinstance(data, TomwerScanBase)
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
@@ -121,14 +121,10 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
             norm_process.run()
         except Exception as e:
             _logger.error(str(e))
-            mess = "Intensity normalization computation for {} failed.".format(
-                str(self._scan)
-            )
+            mess = f"Intensity normalization computation for {self._scan} failed."
             state = DatasetState.FAILED
         else:
-            mess = "Intensity normalization computation for {} succeed.".format(
-                str(self._scan)
-            )
+            mess = f"Intensity normalization computation for {self._scan} succeed."
             state = DatasetState.WAIT_USER_VALIDATION
 
         ProcessManager().notify_dataset_state(

tomwer/synctools/stacks/reconstruction/saaxis.py

@@ -27,20 +27,22 @@ __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.saaxis import SAAxisProcess
-from processview.core.manager import ProcessManager
-from tomwer.synctools.saaxis import QSAAxisParams
-from tomwer.synctools.axis import QAxisRP
 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.io.utils import format_stderr_stdout
-from silx.gui import qt
-import logging
-import functools
+from tomwer.synctools.axis import QAxisRP
+from tomwer.synctools.saaxis import QSAAxisParams
+
+from ..processingstack import FIFO, ProcessingThread
 
 _logger = logging.getLogger(__name__)
 
@@ -68,7 +70,7 @@ class SAAxisProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("start saaxis {}" "".format(str(data)))
+        _logger.processStarted(f"start saaxis {data}")
         assert isinstance(data, TomwerScanBase)
         if data.axis_params is None:
             data.axis_params = QAxisRP()
@@ -79,7 +81,7 @@ class SAAxisProcessStack(FIFO, qt.QObject):
         saaxis_params.frame_width = data.dim_1
         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 saaxis calculation", data.path
+            mess = f"low memory, skip saaxis calculation {data.path}"
             ProcessManager().notify_dataset_state(
                 dataset=data, process=self._process_id, state=DatasetState.SKIPPED
             )