tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

tomwer/core/process/reconstruction/nabu/nabuscores.py

@@ -49,6 +49,7 @@ else:
     has_nabu = True
 import logging
 import os
+from copy import deepcopy
 from typing import Iterable, Optional, Union
 
 from nabu.pipeline.fullfield.nabu_config import (
@@ -64,7 +65,6 @@ from tomwer.core.process.reconstruction.nabu.nabuslices import (
 )
 from tomwer.core.process.reconstruction.nabu.target import Target
 from tomwer.core.progress import Progress
-from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.slurm import is_slurm_available
 from tomwer.utils import docstring
@@ -85,6 +85,8 @@ def run_nabu_one_slice_several_config(
     file_format: str,
     advancement: Optional[Progress] = None,
     process_id: Optional[int] = None,
+    instanciate_classes_only: bool = False,
+    output_file_prefix_pattern=None,
 ) -> tuple:
     """
     Run several reconstruction of a specific slice.
@@ -97,6 +99,7 @@ def run_nabu_one_slice_several_config(
     :param Optional[int] process_id: id of the process requesting this computation
     :param Optional[dict] cluster_config: cluster configuration if
     :return: success, recons_urls (list of output urls), tuple of outs, tuples of errs, dict future_scans (key is cor, value is future_scan)
+             if `instanciate_classes_only` set to True then return a list of :class:`_Reconstructor`
     :rtype: tuple
     """
     if cluster_config in (None, {}):
@@ -128,7 +131,11 @@ def run_nabu_one_slice_several_config(
         file_format=file_format,
         cluster_config=cluster_config,
         process_name=process_name,
+        output_file_prefix_pattern=output_file_prefix_pattern,
     )
+    if instanciate_classes_only:
+        return (reconstructor,)
+
     try:
         results = reconstructor.run()
     except TimeoutError as e:
@@ -137,26 +144,26 @@ def run_nabu_one_slice_several_config(
     else:
         assert isinstance(
             results, dict
-        ), "results should be a dictionary with cor as key and urls as value"
+        ), "results should be a dictionary with var_value as key and urls as value"
         success = True
         recons_urls = {}
         std_outs = []
         std_errs = []
         future_tomo_objs = {}
-        for cor, res in results.items():
+        for var_value, res in results.items():
             success = success and res.success
             if isinstance(res, ResultsWithStd):
                 std_outs.append(res.std_out)
                 std_errs.append(res.std_err)
             if isinstance(res, ResultsLocalRun):
-                recons_urls[cor] = res.results_urls
+                recons_urls[var_value] = res.results_urls
             if isinstance(res, ResultSlurmRun):
                 future_tomo_obj = FutureTomwerObject(
                     tomo_obj=scan,
                     process_requester_id=process_id,
                     futures=res.future_slurm_jobs,
                 )
-                future_tomo_objs[cor] = future_tomo_obj
+                future_tomo_objs[var_value] = future_tomo_obj
         return success, recons_urls, std_outs, std_errs, future_tomo_objs
 
 
@@ -172,7 +179,14 @@ class _Reconstructor(_NabuBaseReconstructor):
         file_format: str,
         cluster_config: Optional[dict],
         process_name: str,
+        output_file_prefix_pattern=None,
     ) -> None:
+        """
+        :param str extra_output_file_pattern: possible extra file name pattern like for cor we want to add 'cor_' as prefix and cor value as suffix.
+                                              To make the file name unique. For delta/beta it is already forseen to be unique. For now keywords are:
+                                              * file_name: default file name according to db values and dataset name
+                                              * value: value of the nabu_configs keys
+        """
         super().__init__(
             scan=scan,
             dry_run=dry_run,
@@ -189,6 +203,7 @@ class _Reconstructor(_NabuBaseReconstructor):
         self.slice_index = slice_index
         self.nabu_configs = nabu_configs
         self.file_format = file_format
+        self._output_file_prefix_pattern = output_file_prefix_pattern
 
     @docstring(_NabuBaseReconstructor)
     def run(self) -> Iterable:
@@ -204,8 +219,12 @@ class _Reconstructor(_NabuBaseReconstructor):
         results = {}
         if self.advancement:
             self.advancement.setMaxAdvancement(len(self.nabu_configs))
-        for cor, config in self.nabu_configs.items():
-            config, conf_file = self.preprocess_config(config, cor)
+        for var_value, config in self.nabu_configs.items():
+            if self._cancelled:
+                break
+            config, conf_file = self.preprocess_config(deepcopy(config), var_value)
+            print("conf file is", conf_file)
+            print("confif output is", config.get("output"))
 
             # add some tomwer metadata and save the configuration
             # note: for now the section is ignored by nabu but shouldn't stay that way
@@ -217,7 +236,7 @@ class _Reconstructor(_NabuBaseReconstructor):
                     options_level="advanced",
                 )
 
-            results[cor] = self._process_config(
+            results[var_value] = self._process_config(
                 config_to_dump=config_to_dump,
                 config_file=conf_file,
                 file_format=self.file_format,
@@ -231,7 +250,36 @@ class _Reconstructor(_NabuBaseReconstructor):
                 self.advancement.increaseAdvancement(1)
         return results
 
-    def treateOutputConfig(self, _config, cor):
+    def _format_file_prefix(self, file_prefix, value):
+        if self._output_file_prefix_pattern is None:
+            return file_prefix
+
+        keywords = {
+            "file_name": file_prefix,
+            "value": value,
+        }
+
+        # filter necessary keywords
+        def get_necessary_keywords():
+            import string
+
+            formatter = string.Formatter()
+            return [
+                field
+                for _, field, _, _ in formatter.parse(self._output_file_prefix_pattern)
+                if field
+            ]
+
+        requested_keywords = get_necessary_keywords()
+
+        def keyword_needed(pair):
+            keyword, _ = pair
+            return keyword in requested_keywords
+
+        keywords = dict(filter(keyword_needed, keywords.items()))
+        return self._output_file_prefix_pattern.format(**keywords)
+
+    def treateOutputConfig(self, _config, value):
         """
         - add or overwrite some parameters of the dictionary
         - create the output directory if does not exist
@@ -249,33 +297,26 @@ class _Reconstructor(_NabuBaseReconstructor):
             if "delta_beta" in _config["phase"]:
                 db = round(float(_config["phase"]["delta_beta"]))
         if "output" in _config:
-            _file_name = SingleSliceRunner.get_file_basename_reconstruction(
+            file_prefix = SingleSliceRunner.get_file_basename_reconstruction(
                 scan=self.scan,
                 slice_index=self.slice_index,
                 pag=pag,
                 db=db,
                 ctf=ctf,
             )
-            _config["output"]["file_prefix"] = f"cor_{_file_name}_{cor}"
-            if _config["output"]["location"] not in ("", None):
-                # if user specify the location
-                if not os.path.isdir(_config["output"]["location"]):
-                    os.makedirs(_config["output"]["location"])
-            else:
-                # otherwise default location will be the data root level
-                _config["output"]["location"] = os.sep.join(
-                    [
-                        self.scan.path,
-                        "saaxis_results",
-                    ]
-                )
+            file_prefix = self._format_file_prefix(file_prefix=file_prefix, value=value)
+            _config["output"]["file_prefix"] = file_prefix
+            assert _config["output"]["location"] not in ("", None)
+            if not os.path.isdir(_config["output"]["location"]):
+                os.makedirs(_config["output"]["location"])
+
         if "reconstruction" not in _config:
             _config["reconstruction"] = {}
         _config["reconstruction"]["start_z"] = self.slice_index
         _config["reconstruction"]["end_z"] = self.slice_index
-        return _config
+        return _config, file_prefix
 
-    def preprocess_config(self, config, cor: float):
+    def preprocess_config(self, config, value: float):
         dataset_params = self.scan.get_nabu_dataset_info()
         if "dataset" in config:
             dataset_params.update(config["dataset"])
@@ -289,7 +330,7 @@ class _Reconstructor(_NabuBaseReconstructor):
             config["output"] = {}
         config["output"].update({"overwrite_results": 1})
 
-        config = self.treateOutputConfig(config, cor=cor)
+        config, file_prefix = self.treateOutputConfig(config, value=value)
         # the policy is to save nabu .cfg file at the same location as the
         # force overwrite results
 
@@ -297,13 +338,9 @@ class _Reconstructor(_NabuBaseReconstructor):
             config["output"]["location"],
             nabu_settings.NABU_CFG_FILE_FOLDER,
         )
-        if not os.path.exists(cfg_folder):
-            os.makedirs(cfg_folder)
+        os.makedirs(cfg_folder, exist_ok=True)
 
-        name = (
-            config["output"]["file_prefix"] + nabu_settings.NABU_CONFIG_FILE_EXTENSION
+        conf_file = os.path.join(
+            cfg_folder, file_prefix + nabu_settings.NABU_CONFIG_FILE_EXTENSION
         )
-        if not isinstance(self.scan, EDFTomoScan):
-            name = "_".join((self.scan.entry.lstrip("/"), name))
-        conf_file = os.path.join(cfg_folder, f"cor_{cor}_{name}")
         return config, conf_file

tomwer/core/process/reconstruction/nabu/nabuslices.py

@@ -32,8 +32,11 @@ import copy
 import functools
 import logging
 import os
+import gc
+from tomwer.io.utils import format_stderr_stdout
+from silx.utils.deprecation import deprecated, deprecated_warning
 
-from processview.core.manager.manager import ProcessManager
+from processview.core.manager.manager import ProcessManager, DatasetState
 
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.scanutils import data_identifier_to_scan
@@ -105,6 +108,7 @@ def run_slices_reconstruction(
     dry_run: bool = False,
     advancement=None,
     process_id=None,
+    instanciate_classes_only: bool = False,
 ) -> tuple:
     """
     call nabu for a reconstruction on scan with the given configuration
@@ -119,6 +123,7 @@ def run_slices_reconstruction(
     :param stdout: file to redirect stdout
     :param advancement: optional Progress class to display advancement
     :param int process_id: optional process id
+    :param bool instanciate_class_only: if we don't want to run the SingleSliceRunner but only return them. Use case: we want to keep a hand on processing and it can be cancelled
 
     :return: (all_succeed, stdouts, stderrs, final_configs, future_scan)
              * all_succeed: bool, True if all the reconstruction succeed or if all job request succeed.
@@ -174,6 +179,7 @@ def run_slices_reconstruction(
     stdouts = []
     final_configs = []
     futures = []
+    instanciated_classes = []
     all_succeed = True
     if advancement is not None:
         advancement.setMaxAdvancement(len(nabu_configurations))
@@ -188,14 +194,18 @@ def run_slices_reconstruction(
             dry_run=dry_run,
             ask_sinogram_registration=ask_sinogram_registration,
             ask_sinogram_load=ask_sinogram_load,
+            instanciate_class_only=instanciate_classes_only,
         )
-        if slice_index is None:
-            continue
 
         # specific treatments of results
         if result is None:
             # in case of timeout or another issue. Log should already have been provided
             pass
+        elif instanciate_classes_only:
+            instanciated_classes.append(result)
+            continue
+        if slice_index is None:
+            continue
         elif isinstance(result, ResultsLocalRun):
             assert not is_cluster_job, "cluster job should not return ResultsLocalRun"
             stderrs.append(result.std_err)
@@ -226,6 +236,8 @@ def run_slices_reconstruction(
         if advancement is not None:
             advancement.increaseAdvancement(1)
 
+    if instanciate_classes_only:
+        return instanciated_classes
     if is_cluster_job:
         future_tomo_obj = FutureTomwerObject(
             tomo_obj=scan,
@@ -240,16 +252,26 @@ def run_slices_reconstruction(
         return all_succeed, stdouts, stderrs, final_configs, None
 
 
-class NabuSlices(
+class NabuSlicesTask(
     Task,
     SuperviseProcess,
-    input_names=("data",),
+    input_names=(
+        "data",
+        "nabu_params",
+    ),
+    optional_input_names=(
+        "dry_run",
+        "serialize_output_data",
+    ),
     output_names=(
         "data",
         "nabu_params",
+        "future_tomo_obj",
     ),
 ):
-    """Definition of the nabu reconstruction Single process"""
+    """
+    Definition of the nabu reconstruction volume reconstruction process
+    """
 
     def __init__(
         self,
@@ -269,14 +291,15 @@ class NabuSlices(
             node_attrs=node_attrs,
             execinfo=execinfo,
         )
-        if "recons_params" in inputs:
-            raise KeyError("Do not use recons_params but `nabu_recons_params` instead")
-        recons_params = inputs.get("nabu_params", {})
-        self.set_configuration(recons_params)
         self._dry_run = inputs.get("dry_run", False)
+        self._current_processing = None
+        # we can sometime call several time a nabu subprocess. The idea is to keep track of it
+        # if we want to stop the processing
 
     def run(self):
         scan = data_identifier_to_scan(self.inputs.data)
+        configuration = self.inputs.nabu_params
+
         self.outputs.nabu_params = None
         if scan is None:
             self.outputs.data = None
@@ -287,39 +310,143 @@ class NabuSlices(
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
             raise ValueError(f"input type of {scan}: {type(scan)} is not managed" "")
-        assert self.get_configuration() is not None, "configuration should be set"
-        run_slices_reconstruction(
-            scan=scan,
-            config=self.get_configuration(),
-            dry_run=self.dry_run,
-            process_id=self.process_id,
-        )
-        # register result
+        assert isinstance(configuration, dict), "configuration is expected to be a dict"
+
         entry = "entry"
         if isinstance(scan, HDF5TomoScan):
             entry = scan.entry
 
+        output_urls = []
+        stderrs = []
+        stdouts = []
+        final_configs = []
+        futures = []
+        all_succeed = True
+        is_cluster_job = configuration.get("cluster_config", None) is not None
+        # loop is required for distributed since version 2021
+        try:
+            single_slice_runner_instances = run_slices_reconstruction(
+                config=configuration,
+                scan=scan,
+                dry_run=self._dry_run,
+                process_id=self.process_id,
+                instanciate_classes_only=True,
+            )
+        except Exception as e:
+            mess = f"Fail to instanciate slice reconstructor for {str(scan)}. Reason is {e}."
+            _logger.processFailed(mess)
+            ProcessManager().notify_dataset_state(
+                dataset=scan,
+                process=self,
+                state=DatasetState.FAILED,
+                details=mess,
+            )
+            self.outputs.future_tomo_obj = None
+            return
+
+        for slice_runner in single_slice_runner_instances:
+            self._current_processing = slice_runner
+            result = self._current_processing.run()[
+                0
+            ]  # we are expecting a single slice per run in this configuration
+            if result is None:
+                # in case of timeout or another issue. Log should already have been provided
+                pass
+            elif isinstance(result, ResultsLocalRun):
+                assert (
+                    not is_cluster_job
+                ), "cluster job should not return ResultsLocalRun"
+                stderrs.append(result.std_err)
+                stdouts.append(result.std_out)
+                output_urls.extend(result.results_urls)
+                # if slice_index is None this mean that we are simply creating the
+                # .cfg file for nabu full volume.
+            elif isinstance(result, ResultSlurmRun):
+                assert (
+                    is_cluster_job
+                ), "local reconstruction should not return ResultSlurmRun"
+                stderrs.append(result.std_err)
+                stdouts.append(result.std_out)
+                futures.extend(result.future_slurm_jobs)
+            elif not isinstance(result, ResultsRun):
+                raise ValueError(
+                    f"result is expected to be an instance of {ResultsRun} not {type(result)}"
+                )
+
+            # common treatments of results
+            if result is not None:
+                final_configs.append(result.config)
+                all_succeed = all_succeed and result.success
+
+        # update future object and scan latest reconstructions
+        self._current_processing = None
+        if not self._cancelled and is_cluster_job:
+            future_tomo_obj = FutureTomwerObject(
+                tomo_obj=scan,
+                futures=tuple(futures),
+                process_requester_id=self.process_id,
+            )
+            scan.set_latest_reconstructions(output_urls)
+        else:
+            # tag latest reconstructions
+            scan.set_latest_reconstructions(output_urls)
+            future_tomo_obj = None
+
+        process_index = scan.pop_process_index()
+        # update processes information / registration
+        gc.collect()
+
+        # TODO: check output files with the tomoscan validator ?
+        if self._cancelled:
+            state = DatasetState.CANCELLED
+            details = "cancelled by user"
+            future_tomo_obj = None
+            _logger.info(f"Slices computation for {scan} cancelled")
+        else:
+            if not all_succeed:
+                mess = f"Slices computation for {scan} failed."
+                state = DatasetState.FAILED
+                _logger.processFailed(mess)
+            else:
+                state = DatasetState.SUCCEED
+                mess = f"Slices computed for {scan}."
+                _logger.processSucceed(mess)
+            elmts = [
+                format_stderr_stdout(stderr=stderr, stdout=stdout)
+                for stderr, stdout in zip(stderrs, stdouts)
+            ]
+            elmts.insert(0, mess)
+            details = "\n".join(elmts)
+
+        ProcessManager().notify_dataset_state(
+            dataset=scan,
+            process=self,
+            state=state,
+            details=details,
+        )
+
+        # register result
         with scan.acquire_process_file_lock():
             self.register_process(
                 process_file=scan.process_file,
                 entry=entry,
-                configuration=self.get_configuration(),
+                configuration=configuration,
                 results={},
-                process_index=scan.pop_process_index(),
+                process_index=process_index,
                 overwrite=True,
             )
-        self.outputs.data = scan
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan.to_dict()
+        else:
+            self.outputs.data = scan
         self.outputs.nabu_params = scan.nabu_recons_params
+        self.outputs.future_tomo_obj = future_tomo_obj
 
     def set_configuration(self, configuration: dict) -> None:
         Task.set_configuration(self, configuration=configuration)
         if "dry_run" in configuration:
             self.set_dry_run(bool(configuration["dry_run"]))
 
-    # TODO: those get / set configuration should be removed now that Task is used
-    def get_configuration(self):
-        return self._settings
-
     @staticmethod
     def program_name():
         return "nabu-slices"
@@ -328,10 +455,12 @@ class NabuSlices(
     def program_version():
         return nabu_version
 
+    @deprecated(replacement="provide dry_run to the task inputs", since_version="1.2")
     def set_dry_run(self, dry_run):
         self._dry_run = dry_run
 
     @property
+    @deprecated(replacement="Task.inputs.dry_run", since_version="1.2")
     def dry_run(self):
         return self._dry_run
 
@@ -348,8 +477,8 @@ class NabuSlices(
         """
         if entry is None:
             with HDF5File(process_file, "r", swmr=True) as h5f:
-                entries = NabuSlices._get_process_nodes(
-                    root_node=h5f, process=NabuSlices
+                entries = NabuSlicesTask._get_process_nodes(
+                    root_node=h5f, process=NabuSlicesTask
                 )
                 if len(entries) == 0:
                     _logger.info("unable to find a Axis process in %s" % process_file)
@@ -364,8 +493,8 @@ class NabuSlices(
         res = {}
 
         with HDF5File(process_file, "r", swmr=True) as h5f:
-            nabu_nodes = NabuSlices._get_process_nodes(
-                root_node=h5f[entry], process=NabuSlices
+            nabu_nodes = NabuSlicesTask._get_process_nodes(
+                root_node=h5f[entry], process=NabuSlicesTask
             )
             index_to_path = {}
             for key, index in nabu_nodes.items():
@@ -402,10 +531,18 @@ class NabuSlices(
             )
         return res
 
+    def cancel(self):
+        """
+        stop current processing
+        """
+        self._cancelled = True
+        if self._current_processing is not None:
+            self._current_processing.cancel()
+
     @staticmethod
     def retrieve_last_relative_cor(scan):
         with EntryReader(scan.process_file_url) as h5f:
-            latest_nabu_node = Task.get_most_recent_process(h5f, NabuSlices)
+            latest_nabu_node = Task.get_most_recent_process(h5f, NabuSlicesTask)
             path = "configuration/reconstruction/rotation_axis_position"
             if latest_nabu_node is not None and path in latest_nabu_node:
                 return h5py_read_dataset(latest_nabu_node[path])
@@ -446,6 +583,17 @@ def interpret_tomwer_configuration(
     else:
         pag_dbs = (None,)
 
+    # remove slices that 'cannot' be reconstructed (out of bounds)
+    def filter_slice(slice_index: int):
+        if scan.dim_2 is not None and slice_index > scan.dim_2:
+            _logger.error(
+                f"slice index {slice_index} requested. But slice index must be in 0-{scan.dim_2} - ignore this request"
+            )
+            return False
+        return True
+
+    slices = list(filter(lambda slice_index: filter_slice(int(slice_index)), slices))
+
     # by default add the slice 'None' which is the slice for the volume
     slices.append(None)
     nabu_config = get_nabu_config(config=config)
@@ -568,17 +716,15 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             "steps_file": steps_file,
         }
 
-        config = self._treateOutputSliceConfig(config)
+        config, cfg_folder = self._treateOutputSliceConfig(config)
         # the policy is to save nabu .cfg file at the same location as the
         # force overwrite results
         if self.slice_index is not None:
             config["reconstruction"]["start_z"] = self.slice_index
             config["reconstruction"]["end_z"] = self.slice_index
-        cfg_folder = os.path.join(
-            config["output"]["location"], nabu_settings.NABU_CFG_FILE_FOLDER
-        )
-        if not os.path.exists(cfg_folder):
-            os.makedirs(cfg_folder)
+
+        if self.slice_index is not None:
+            os.makedirs(config["output"]["location"], exist_ok=True)
 
         name = (
             config["output"]["file_prefix"] + nabu_settings.NABU_CONFIG_FILE_EXTENSION
@@ -638,8 +784,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 file_format=file_format,
                 scan=self.scan,
                 slice_index=None,
-                start_z=None,  # self.slice_index,
-                end_z=None,  # self.slice_index,
+                start_z=None,
+                end_z=None,
                 expects_single_slice=True,
             )
 
@@ -659,6 +805,13 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         if isinstance(scan, HDF5TomoScan):
             basename, _ = os.path.splitext(scan.master_file)
             basename = os.path.basename(basename)
+            try:
+                with HDF5File(scan.master_file, mode="r") as h5f:
+                    if len(h5f.keys()) > 1:
+                        # if there is more than one entry in the file append the entry name to the file basename
+                        basename = "_".join((basename, scan.entry.lstrip("/")))
+            except Exception:
+                pass
         else:
             basename = os.path.basename(scan.path)
         if slice_index is None:
@@ -673,7 +826,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 return "_".join(
                     (
                         basename + "slice_pag",
-                        str(slice_index).zfill(4),
+                        str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
                     )
                 )
@@ -681,12 +834,12 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 return "_".join(
                     (
                         basename + "slice_ctf",
-                        str(slice_index).zfill(4),
+                        str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
                     )
                 )
             else:
-                return "_".join((basename + "slice", str(slice_index).zfill(4)))
+                return "_".join((basename + "slice", str(slice_index).zfill(6)))
 
     @docstring(_NabuBaseReconstructor)
     def _get_file_basename_reconstruction(self, pag, db, ctf):
@@ -715,6 +868,7 @@ def run_single_slice_reconstruction(
     process_id: Optional[int] = None,
     cluster_config: Optional[dict] = None,
     add_to_latest_reconstructions=True,
+    instanciate_class_only=False,
 ) -> Optional[ResultsRun]:
     """
     # TODO: might need something like a context or an option "keep" slice in memory
@@ -732,6 +886,7 @@ def run_single_slice_reconstruction(
     :param bool ask_sinogram_load: should we ask nabu to load sinogram
     :param bool add_to_latest_reconstructions: if true add reconstructed slice to the latest reconstruction.
                                                We wan't to avoid this treatment for saaxis and sadeltebeta for example
+    :param bool instanciate_class_only: if we don't want to run the SingleSliceRunner but only return them. Use case: we want to keep a hand on processing and it can be cancelled
     :return: result of the slice reconstruction if succeed to launch it.
     :rtype: Optional[ResultsRun]
     """
@@ -758,6 +913,9 @@ def run_single_slice_reconstruction(
         add_to_latest_reconstructions=add_to_latest_reconstructions,
         process_name=process_name,
     )
+    if instanciate_class_only:
+        return slice_reconstructor
+
     try:
         results = slice_reconstructor.run()
     except TimeoutError as e:
@@ -793,3 +951,23 @@ class NabuSliceMode(_Enum):
                     "an unique value or a list or a tuple"
                 )
         return tuple(res)
+
+
+class NabuSlices(NabuSlicesTask):
+    def __init__(
+        self,
+        process_id=None,
+        varinfo=None,
+        inputs=None,
+        node_id=None,
+        node_attrs=None,
+        execinfo=None,
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.reconstruction.nabu.nabuslices.Nabuslices",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="NabuSlicesTask",
+        )
+        super().__init__(process_id, varinfo, inputs, node_id, node_attrs, execinfo)