tomwer 1.2.8__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

tomwer/app/zstitching.py

@@ -5,17 +5,21 @@ import argparse
 import logging
 import signal
 import sys
+import functools
 
 from silx.gui import qt
 
 from nabu.utils import Progress
 from nabu.stitching.config import StitchingType
 
+from tomwer.core.settings import SlurmSettingsMode
 from tomwer.core.utils.resource import increase_max_number_file
+from tomwer.gui import icons
 from tomwer.core.process.stitching.nabustitcher import StitcherTask
 from tomwer.io.utils.tomoobj import get_tomo_objs_instances
 from tomwer.gui.utils.splashscreen import getMainSplashScreen
 from tomwer.gui.stitching.stitching import ZStitchingWindow as _ZStitchingWindow
+from tomwer.gui.stitching import action as stitching_action
 from tomwer.gui.cluster.slurm import SlurmSettingsWidget
 
 logging.basicConfig(level=logging.WARNING)
@@ -31,12 +35,30 @@ class MainWidget(qt.QTabWidget):
         parent=None,
     ) -> None:
         super().__init__(parent)
-        self._stitchingConfigWindow = _ZStitchingWindow(parent=self)
+        self._stitchingConfigWindow = _ZStitchingWindow(
+            parent=self, with_configuration_action=False
+        )
         self.addTab(self._stitchingConfigWindow, "stitching config")
+        settingsClass = SlurmSettingsMode.get_settings_class(
+            SlurmSettingsMode.STITCHING
+        )
         self._slurmConfig = SlurmSettingsWidget(
-            parent=self, n_gpu=0, jobLimitation=None
+            parent=self, n_gpu=settingsClass.N_GPUS_PER_WORKER, jobLimitation=None
         )
-        self._slurmConfig.setNJobs(20)
+        self._slurmConfig.setConfiguration(
+            {
+                "cpu-per-task": settingsClass.N_CORES_PER_TASK,
+                "n_tasks": settingsClass.N_TASKS,
+                "n_jobs": settingsClass.N_JOBS,
+                "memory": settingsClass.MEMORY_PER_WORKER,
+                "partition": settingsClass.PARTITION,
+                "n_gpus": settingsClass.N_GPUS_PER_WORKER,
+                "job_name": settingsClass.PROJECT_NAME,
+                "walltime": settingsClass.DEFAULT_WALLTIME,
+                "python_venv": settingsClass.PYTHON_VENV,
+            }
+        )
+
         self._stitchingConfigWindow.setCallbackToGetSlurmConfig(
             self._slurmConfig.getConfiguration
         )
@@ -133,16 +155,63 @@ class MainWindow(qt.QDialog):
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
+        # menu
+        self._menuBar = qt.QMenuBar(self)
+        self.layout().addWidget(self._menuBar)
+        self._menu = qt.QMenu("&Stitching")
+        self._menuBar.addMenu(self._menu)
+        # save / load configuration
+        self._loadConfigurationAction = stitching_action.LoadConfigurationAction(
+            self, "&Load configuration"
+        )
+        self._menu.addAction(self._loadConfigurationAction)
+        self._saveConfigurationAction = stitching_action.SaveConfigurationAction(
+            self, "&Save configuration"
+        )
+        self._menu.addAction(self._saveConfigurationAction)
+        # separator
+        self._menu.addSeparator()
+        # add tomo object
+        self._addTomoObjectAction = stitching_action.AddTomoObjectAction(
+            self, "&Add tomo object (volume or NXtomo)"
+        )
+        self._menu.addAction(self._addTomoObjectAction)
+
+        # main window
         self.setWindowTitle("tomwer z-stitching")
         self._mainWindow = MainWidget(parent=self)
         self.layout().addWidget(self._mainWindow)
 
+        # button
         types = qt.QDialogButtonBox.Apply
         self._buttons = qt.QDialogButtonBox(self)
         self._buttons.setStandardButtons(types)
         self.layout().addWidget(self._buttons)
         self._buttons.button(qt.QDialogButtonBox.Apply).setText("Launch stitching")
+
+        # connect signal / slot
         self._buttons.button(qt.QDialogButtonBox.Apply).clicked.connect(self.accept)
+        self._loadConfigurationAction.triggered.connect(
+            functools.partial(
+                self._mainWindow._stitchingConfigWindow._loadSettings, file_path=None
+            )
+        )
+        self._saveConfigurationAction.triggered.connect(
+            functools.partial(
+                self._mainWindow._stitchingConfigWindow._saveSettings, file_path=None
+            )
+        )
+        self._addTomoObjectAction.triggered.connect(self._callbackAddTomoObj)
+
+    def _callbackAddTomoObj(self, *args, **kwargs):
+        """move interface to the z-ordered list and call the 'add tomo obj' callback"""
+        orderedListWidget = (
+            self._mainWindow._stitchingConfigWindow._widget._mainWidget._zOrderedList
+        )
+        self._mainWindow._stitchingConfigWindow._widget._mainWidget.setCurrentWidget(
+            orderedListWidget
+        )
+        orderedListWidget._callbackAddTomoObj()
 
     def close(self):
         self._mainWindow.close()
@@ -258,6 +327,8 @@ def main(argv):
 
     window = MainWindow()
     window.setWindowFlags(qt.Qt.Window)
+    window.setWindowTitle("tomwer: z-stitching")
+    window.setWindowIcon(icons.getQIcon("tomwer"))
 
     window.show()
     from sluurp.utils import has_sbatch_available

tomwer/core/cluster/cluster.py

@@ -31,8 +31,11 @@ __license__ = "MIT"
 __date__ = "12/10/2021"
 
 
+import logging
 from tomwer.core.settings import SlurmSettings as _SlurmSettings
 
+_logger = logging.getLogger(__name__)
+
 
 class SlurmClusterConfiguration:
     """Object shipping the configuration of a slurm cluster"""
@@ -48,6 +51,8 @@ class SlurmClusterConfiguration:
         walltime=_SlurmSettings.DEFAULT_WALLTIME,
         python_venv=_SlurmSettings.PYTHON_VENV,
         n_jobs=_SlurmSettings.N_JOBS,
+        modules_to_load: tuple = _SlurmSettings.MODULES_TO_LOAD,
+        sbatch_extra_params: dict = _SlurmSettings.SBATCH_EXTRA_PARAMS,
     ) -> None:
         self._n_cpu_per_task = n_cpu_per_task
         self._n_task = n_tasks
@@ -57,7 +62,13 @@ class SlurmClusterConfiguration:
         self._project_name = project_name
         self._walltime = walltime
         self._python_venv = python_venv
+        self._modules_to_load = modules_to_load
         self._n_jobs = n_jobs
+        self._sbatch_extra_params = sbatch_extra_params
+        if python_venv not in (None, "") and len(modules_to_load) > 0:
+            _logger.warning(
+                "Either 'modules to load' of 'python venv' can be provided. Not both"
+            )
 
     @property
     def n_cpu_per_task(self):
@@ -95,11 +106,19 @@ class SlurmClusterConfiguration:
     def python_venv(self):
         return self._python_venv
 
+    @property
+    def modules_to_load(self) -> tuple:
+        return self._modules_to_load
+
     @property
     def port_range(self) -> tuple:
         """port range as (start:int, strop:int, step: int)"""
         return self._port_range
 
+    @property
+    def sbatch_extra_params(self) -> dict:
+        return self._sbatch_extra_params
+
     @property
     def dashboard_port(self):
         return self._dashboard_port
@@ -115,6 +134,8 @@ class SlurmClusterConfiguration:
             "job_name": self.project_name,
             "walltime": self.walltime,
             "python_venv": self.python_venv,
+            "modules": self.modules_to_load,
+            "sbatch_extra_params": self.sbatch_extra_params,
         }
 
     @staticmethod
@@ -140,8 +161,13 @@ class SlurmClusterConfiguration:
             self._walltime = dict_["walltime"]
         if "python_venv" in dict_:
             self._python_venv = dict_["python_venv"]
+        modules = dict_.get("modules", None)
+        if modules is not None:
+            self._modules_to_load = modules
         if "port_range" in dict_:
             self._port_range = dict_["port_range"]
         if "dashboard_port" in dict_:
             self._dashboard_port = dict_["dashboard_port"]
+        if "sbatch_extra_params" in dict_:
+            self._sbatch_extra_params = dict_["sbatch_extra_params"]
         return self

tomwer/core/log/logger.py

@@ -51,10 +51,14 @@ from tomwer.core.log.processlog import (
 
 # These are the sequences need to get colored ouput
 _RESET_SEQ = "\033[0m"
-_COLOR_SEQ = "\033[1;%dm"
 _BOLD_SEQ = "\033[1m"
 
-_BLACK, _RED, _GREEN, _YELLOW, _BLUE, _MAGENTA, _CYAN, _WHITE = range(8)
+_BLACK = "\033[30m"
+_RED = "\033[31m"
+_GREEN = "\033[32m"
+_YELLOW = "\033[33m"
+_BLUE = "\033[34m"
+_MAGENTA = "\033[35m"
 
 LOG_COLORS = {
     "WARNING": _MAGENTA,
@@ -90,9 +94,7 @@ class _ColoredFormatter(logging.Formatter):
     def format(self, record):
         levelname = record.levelname
         if self.use_color is True and levelname in LOG_COLORS:
-            levelname_color = (
-                _COLOR_SEQ % (30 + LOG_COLORS[levelname]) + levelname + _RESET_SEQ
-            )
+            levelname_color = LOG_COLORS[levelname] + levelname + _RESET_SEQ
             record.levelname = levelname_color
         record.asctime = self.formatTime(record, self.datefmt)
         return logging.Formatter.format(self, record)

tomwer/core/process/conditions/filters.py

@@ -41,7 +41,7 @@ from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 
-from silx.utils.deprecation import deprecated_warning
+from tomwer.core.utils.deprecation import deprecated_warning
 
 _logger = logging.getLogger(__name__)
 

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

@@ -43,7 +43,7 @@ import tomwer.version
 from tomwer.core import settings
 from tomwer.core.process.task import BaseProcessInfo
 from tomwer.core.scan.blissscan import BlissScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 
 from .rpcserver import DataListenerThread
 
@@ -191,7 +191,7 @@ class DataListener(BaseProcessInfo):
         for mf_emf in self.convert(bliss_file=sample_file, entry=entry):
             master_file, entry_master_file = mf_emf
             if master_file is not None and entry_master_file is not None:
-                scan = HDF5TomoScan(scan=master_file, entry=entry_master_file)
+                scan = NXtomoScan(scan=master_file, entry=entry_master_file)
 
                 try:
                     # register process.
@@ -548,7 +548,7 @@ class DataListener(BaseProcessInfo):
         return res == "Y"
 
     def _signal_scan_ready(self, scan):
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         pass
 
     def activate(self, activate=True):

tomwer/core/process/control/nxtomoconcatenate.py

@@ -5,10 +5,10 @@ from tomoscan.serie import Serie
 from ewokscore.missing_data import is_missing_data
 
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 
-from nxtomomill.nexus.nxtomo import NXtomo
-from nxtomomill.nexus.utils import concatenate as nx_concatenate
+from nxtomo.application.nxtomo import NXtomo
+from nxtomomill.utils.nexus import concatenate as nx_concatenate
 
 _logger = logging.getLogger(__name__)
 
@@ -28,7 +28,7 @@ class ConcatenateNXtomoTask(
     output_names=("data",),
 ):
     """
-    Task used to concatenate a list of NXtomo (HDF5TomoScan) into a single NXtomo
+    Task used to concatenate a list of NXtomo (NXtomoScan) into a single NXtomo
     """
 
     def run(self):
@@ -43,17 +43,17 @@ class ConcatenateNXtomoTask(
             file_path=self.inputs.output_file, serie=scans_serie
         )
 
-        # cast scan from HDF5tomoScan to NXtomo
-        def cast_scan_to_nxtomo(obj: HDF5TomoScan):
-            # convert HDF5Tomoscan to NXtomo as we expect to get HDF5TomoScan
-            if isinstance(obj, HDF5TomoScan):
+        # cast scan from NXtomoScan to NXtomo
+        def cast_scan_to_nxtomo(obj: NXtomoScan):
+            # convert NXtomoScan to NXtomo as we expect to get NXtomoScan
+            if isinstance(obj, NXtomoScan):
                 return NXtomo().load(
                     file_path=obj.master_file,
                     data_path=obj.entry,
                 )
             else:
                 raise TypeError(
-                    f"nxtomos are supposed to be instances of {NXtomo} or {HDF5TomoScan}. Get {type(obj)}"
+                    f"nxtomos are supposed to be instances of {NXtomo} or {NXtomoScan}. Get {type(obj)}"
                 )
 
         scans_serie = tuple([cast_scan_to_nxtomo(nxtomo) for nxtomo in scans_serie])
@@ -68,8 +68,8 @@ class ConcatenateNXtomoTask(
             overwrite=self.inputs.overwrite,
         )
 
-        # cast back nxtomomill NXtomo to HDF5TomoScan (reference object for tomwer)
-        scan = HDF5TomoScan(
+        # cast back nxtomomill NXtomo to NXtomoScan (reference object for tomwer)
+        scan = NXtomoScan(
             scan=output_file,
             entry=self.inputs.output_entry,
         )
@@ -84,14 +84,14 @@ def format_output_location(file_path, serie: Serie):
     format possible keys from the location like {scan_dir} or {scan_path}
 
     :param file_path:
-    :param serie: serie of HDF5TomoScan
+    :param serie: serie of NXtomoScan
     :return:
     """
     if serie is None:
         _logger.warning("scan is !none, enable to format the nabu output location")
 
     for scan in serie:
-        if not isinstance(scan, HDF5TomoScan):
+        if not isinstance(scan, NXtomoScan):
             raise TypeError
 
     def get_common_path():

tomwer/core/process/control/nxtomomill.py

@@ -23,6 +23,8 @@
 #
 # ###########################################################################*/
 
+from __future__ import annotations
+
 __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "30/07/2020"
@@ -32,25 +34,24 @@ import logging
 import os
 import pathlib
 
+from tomoscan.serie import Serie
+
 from nxtomomill import converter as nxtomomill_converter
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
 from nxtomomill.io.config import TomoHDF5Config as HDF5Config
-from nxtomomill.converter.hdf5.utils import get_default_output_file
+from nxtomomill.converter.hdf5.utils import (
+    get_default_output_file,
+)
 
+from tomwer.io.utils.raw_and_processed_data import to_raw_data_path
+from tomwer.core.process.output import ProcessDataOutputDirMode
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.utils.scanutils import format_output_location
 
-from silx.utils.enum import Enum as _Enum
-
 _logger = logging.getLogger(__name__)
 
 
-class NXtomomillNXDefaultOutput(_Enum):
-    NEAR_INPUT_FILE = "near input"
-    PROCESSED_DATA = "processed data dir"
-
-
 class H5ToNxProcess(
     TaskWithProgress,
     input_names=("h5_to_nx_configuration",),
@@ -59,7 +60,7 @@ class H5ToNxProcess(
         "hdf5_scan",
         "serialize_output_data",
     ),
-    output_names=("data", "datas"),
+    output_names=("data", "serie"),
 ):
     """
     Task to convert from a bliss dataset to a nexus compliant dataset
@@ -67,21 +68,29 @@ class H5ToNxProcess(
 
     @staticmethod
     def deduce_output_file_path(master_file_name, scan, entry, outputdir):
-        assert isinstance(outputdir, str), "outputdir is expected to be a str"
-
         master_file_name = os.path.realpath(master_file_name)
         # step 1: get output dir
         try:
-            outputdir = NXtomomillNXDefaultOutput.from_value(outputdir)
+            outputdir = ProcessDataOutputDirMode.from_value(outputdir)
         except ValueError:
+            # case path provided directly
             output_folder = format_output_location(outputdir, scan=scan)
         else:
-            if outputdir is NXtomomillNXDefaultOutput.PROCESSED_DATA:
+            if outputdir is ProcessDataOutputDirMode.OTHER:
+                raise ValueError(
+                    f"When output dir mode is {ProcessDataOutputDirMode.OTHER} we expect to received the output dir directly"
+                )
+            if outputdir is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
                 path = pathlib.Path(
                     get_default_output_file(input_file=master_file_name)
                 )
                 output_folder = str(path.parent)
-            elif outputdir is NXtomomillNXDefaultOutput.NEAR_INPUT_FILE:
+            elif outputdir is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+                path = pathlib.Path(
+                    get_default_raw_data_output_file(input_file=master_file_name)
+                )
+                output_folder = str(path.parent)
+            elif outputdir is ProcessDataOutputDirMode.IN_SCAN_FOLDER:
                 output_folder = os.path.dirname(master_file_name)
             else:
                 raise RuntimeError(f"output dir {outputdir} not handled")
@@ -119,10 +128,10 @@ class H5ToNxProcess(
         if len(convs) == 0:
             return
 
-        datas = []
+        serie = []
         for conv in convs:
             conv_file, conv_entry = conv
-            scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
+            scan_converted = NXtomoScan(scan=conv_file, entry=conv_entry)
             _logger.processSucceed(
                 f"{config.input_file} {config.entries} has been translated to {scan_converted}"
             )
@@ -130,9 +139,11 @@ class H5ToNxProcess(
                 data = scan_converted.to_dict()
             else:
                 data = scan_converted
-            datas.append(data)
-        self.outputs.datas = datas
-        self.outputs.data = datas[-1] if len(datas) > 0 else None
+            serie.append(data)
+        self.outputs.serie = Serie(
+            name=f"serie created from {config.input_file}", iterable=serie
+        )
+        self.outputs.data = serie[-1] if len(serie) > 0 else None
 
 
 class EDFToNxProcess(
@@ -157,23 +168,70 @@ class EDFToNxProcess(
             raise TypeError(
                 "edf_to_nx_configuration should be a dict or an instance of {TomoEDFConfig}"
             )
+        os.makedirs(os.path.dirname(config.output_file), exist_ok=True)
         file_path, entry = nxtomomill_converter.from_edf_to_nx(
             configuration=config, progress=self.progress
         )
-        scan = HDF5TomoScan(entry=entry, scan=file_path)
+        scan = NXtomoScan(entry=entry, scan=file_path)
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
             self.outputs.data = scan
 
     @staticmethod
-    def deduce_output_file_path(folder_path, output_dir, scan):
-        if output_dir in (None, NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value):
+    def deduce_output_file_path(
+        folder_path, output_dir: ProcessDataOutputDirMode | str, scan
+    ):
+        try:
+            output_dir = ProcessDataOutputDirMode.from_value(output_dir)
+        except Exception:
+            pass
+
+        if output_dir is ProcessDataOutputDirMode.OTHER:
+            raise ValueError("if mode is other, we expect 'output_dir' to be the path")
+        elif output_dir in (None, ProcessDataOutputDirMode.IN_SCAN_FOLDER):
             output_folder = os.path.dirname(folder_path)
-        elif output_dir == NXtomomillNXDefaultOutput.PROCESSED_DATA.value:
+        elif output_dir is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
             path = pathlib.Path(get_default_output_file(folder_path))
             output_folder = str(path.parent)
+        elif output_dir is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+            path = pathlib.Path(get_default_raw_data_output_file(folder_path))
+            output_folder = str(path.parent)
         else:
+            # else we expect people to provide output location
             output_folder = format_output_location(output_dir, scan=scan)
-        print("output output_folder is", output_folder)
         return os.path.join(output_folder, os.path.basename(folder_path) + ".nx")
+
+
+def get_default_raw_data_output_file(
+    input_file: str, output_file_extension: str = ".nx"
+) -> str:
+    """
+    Policy: look for any 'RAW_DATA' in file directory. If find any (before any 'PROCESSED_DATA' directory) replace it "RAW_DATA".
+    Then replace input_file by the expected file_extension and make sure the output file is different than the input file. Else append _nxtomo to it.
+
+    :param str input_file: file to be converted from bliss to NXtomo
+    :param str output_file_extension:
+    :return: default output file according to policy
+    """
+    if isinstance(input_file, pathlib.Path):
+        input_file = str(input_file)
+    if not isinstance(input_file, str):
+        raise TypeError(
+            f"input_file is expected to be an instance of str. {type(input_file)} provided"
+        )
+    if not isinstance(output_file_extension, str):
+        raise TypeError("output_file_extension is expected to be a str")
+    if not output_file_extension.startswith("."):
+        output_file_extension = "." + output_file_extension
+
+    input_file = os.path.abspath(input_file)
+    input_file_no_ext, _ = os.path.splitext(input_file)
+
+    output_path = to_raw_data_path(input_file_no_ext)
+    output_file = output_path + output_file_extension
+    if output_file == input_file:
+        # to be safer if the default output file is the same as the input file (if the input file has a .nx extension and not in any 'RAw_DATA' directory)
+        return output_path + "_nxtomo" + output_file_extension
+    else:
+        return output_file

tomwer/core/process/control/scantransfer.py

@@ -32,19 +32,20 @@ import fnmatch
 import logging
 import os
 import shutil
-from silx.utils.deprecation import deprecated_warning
+from tomwer.core.utils.deprecation import deprecated_warning
 
 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.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 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 import logconfig
+from tomwer.core.utils.spec import rebaseParFile
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.io.utils import get_linked_files_with_entry
 
@@ -103,7 +104,7 @@ class ScanTransferTask(
         self._copying = inputs.get("copying", False)
         force_sync = inputs.get("force_sync", None)
         if force_sync is not None:
-            from silx.utils.deprecation import deprecated_warning
+            from tomwer.core.utils.deprecation import deprecated_warning
 
             deprecated_warning(
                 type_="Parameter",
@@ -190,7 +191,7 @@ class ScanTransferTask(
             else:
                 output_scan = scan._deduce_transfert_scan(outputdir)
                 try:
-                    output_scan._update_latest_recons_urls(
+                    output_scan._update_latest_recons_identifiers(
                         old_path=scan.path, new_path=output_scan.path
                     )
                 except Exception as e:
@@ -211,7 +212,7 @@ class ScanTransferTask(
             self._signalCopying(scanID=source, outputdir=target)
             output_scan = scan._deduce_transfert_scan(outputdir)
             try:
-                output_scan._update_latest_recons_urls(
+                output_scan._update_latest_recons_identifiers(
                     old_path=scan.path, new_path=output_scan.path
                 )
             except Exception as e:
@@ -266,7 +267,7 @@ class ScanTransferTask(
         return self._getOutputDirSpec() or self._getOutputDirLBS(bliss_sample_file)
 
     def _process_hdf5_scan(self, scan) -> TomwerScanBase:
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         from tomwer.core.process.control.datalistener import DataListener
 
         files_sources = []
@@ -339,7 +340,7 @@ class ScanTransferTask(
             files_sources.append(scan.master_file)
             files_dest.append(new_nx_file)
             delete_opt.append(True)
-            output_scan = HDF5TomoScan(scan=new_nx_file, entry=scan.entry)
+            output_scan = NXtomoScan(scan=new_nx_file, entry=scan.entry)
         else:
             output_scan = None
 
@@ -482,7 +483,7 @@ class ScanTransferTask(
                 overwrite=self.get_input_value("overwrite", True),
                 noRsync=self._noRsync,
             )
-        elif isinstance(scan, HDF5TomoScan):
+        elif isinstance(scan, NXtomoScan):
             if self._move is True:
                 raise NotImplementedError("move option not implemented")
             if self._noRsync is True:
@@ -530,7 +531,7 @@ class ScanTransferTask(
 
         results = {"input_scan": str(input_scan), "output_scan": str(output_scan)}
         entry = "entry"
-        if isinstance(output_scan, HDF5TomoScan):
+        if isinstance(output_scan, NXtomoScan):
             entry = output_scan.entry
         self.register_process(
             process_file=output_scan.process_file,

tomwer/core/process/control/scanvalidator.py

@@ -31,7 +31,8 @@ import logging
 
 from ewokscore.task import Task as EwoksTask
 
-from tomwer.core import settings, utils
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import is_low_on_memory
 from tomwer.core.process.task import BaseProcessInfo
 from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
 from tomwer.core.scan.scanfactory import ScanFactory
@@ -98,7 +99,7 @@ class ScanValidator(BaseProcessInfo):
 
     def _freeStackIfNeeded(self):
         # if we are low in memory in lbsram: we will automatically validate the current scan
-        isLowMemoryLbs = utils.isLowOnMemory(settings.get_lbsram_path()) is True
+        isLowMemoryLbs = is_low_on_memory(settings.get_lbsram_path()) is True
         if not self.isValidationManual():
             self._validateStack()
         elif isLowMemoryLbs: