tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 try:
     from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
         FullFieldReconstructor,
@@ -19,8 +21,9 @@ import os
 import sys
 from copy import deepcopy
 import subprocess
-from typing import Iterable, Optional, Union
+from typing import Iterable
 import numpy
+from tqdm import tqdm
 
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
@@ -39,8 +42,11 @@ from tomwer.core.process.reconstruction.nabu.utils import (
     slice_index_to_int,
     get_nabu_multicor_file_prefix,
 )
+from tomwer.core.process.reconstruction.utils.cor import (
+    relative_pos_to_absolute,
+    absolute_pos_to_relative,
+)
 from tomwer.core.process.reconstruction.nabu.target import Target
-from tomwer.core.progress import Progress
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
 from tomwer.utils import docstring
@@ -56,30 +62,29 @@ _logger = logging.getLogger(__name__)
 
 def run_nabu_one_slice_several_config(
     scan: TomwerScanBase,
-    nabu_configs: Union[list, tuple],
-    cluster_config: Optional[dict],
+    nabu_configs: list | tuple,
+    cluster_config: dict | None,
     dry_run: bool,
-    slice_index: Union[int, str],
+    slice_index: int | str,
     file_format: str,
     axis: NabuPlane,
-    advancement: Optional[Progress] = None,
-    process_id: Optional[int] = None,
-    instanciate_classes_only: bool = False,
+    advancement: tqdm | None = None,
+    process_id: int | None = None,
+    instantiate_classes_only: bool = False,
     output_file_prefix_pattern=None,
 ) -> tuple:
     """
     Run several reconstruction of a specific slice.
 
     :param scan: dataset
-    :param Iterable nabu_configs: set of nabu configurations to be run
-    :param bool dry_run:
-    :param int slice_index: slice index to reconstruct or "middle"
-    :param Progress advancement: optional class to display advancement
-    :param Optional[int] process_id: id of the process requesting this computation
-    :param Optional[dict] cluster_config: cluster configuration if
+    :param nabu_configs: set of nabu configurations to be run
+    :param dry_run:
+    :param slice_index: slice index to reconstruct or "middle"
+    :param advancement: optional class to display advancement
+    :param process_id: id of the process requesting this computation
+    :param 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 `instantiate_classes_only` set to True then return a list of :class:`_Reconstructor`
     """
     if cluster_config in (None, {}):
         target = Target.LOCAL
@@ -113,7 +118,7 @@ def run_nabu_one_slice_several_config(
         output_file_prefix_pattern=output_file_prefix_pattern,
         axis=axis,
     )
-    if instanciate_classes_only:
+    if instantiate_classes_only:
         return (reconstructor,)
 
     try:
@@ -151,12 +156,12 @@ def run_nabu_multicor(
     scan: TomwerScanBase,
     nabu_config: dict,
     cors: tuple,
-    cluster_config: Optional[dict],
+    cluster_config: dict | None,
     dry_run: bool,
-    slice_index: Union[int, str],
+    slice_index: int | str,
     file_format: str,
-    process_id: Optional[int] = None,
-    instanciate_classes_only: bool = False,
+    process_id: int | None = None,
+    instantiate_classes_only: bool = False,
     output_file_prefix_pattern=None,
 ):
     if cluster_config in (None, {}):
@@ -199,7 +204,7 @@ def run_nabu_multicor(
         axis=axis,
         output_file_prefix_pattern=output_file_prefix_pattern,
     )
-    if instanciate_classes_only:
+    if instantiate_classes_only:
         return reconstructor
 
     try:
@@ -233,13 +238,13 @@ class _Reconstructor(_NabuBaseReconstructor):
         self,
         scan: TomwerScanBase,
         nabu_configs: Iterable,
-        advancement: Optional[Progress],
-        slice_index: Union[int, str],
-        axis: Union[str, NabuPlane],
+        advancement: tqdm | None,
+        slice_index: int | str,
+        axis: str | NabuPlane,
         target: Target,
         dry_run: bool,
         file_format: str,
-        cluster_config: Optional[dict],
+        cluster_config: dict | None,
         process_name: str,
         output_file_prefix_pattern=None,
     ) -> None:
@@ -252,7 +257,7 @@ class _Reconstructor(_NabuBaseReconstructor):
         :param target: is the reconstruction is to made locally or remotly
         :param file_format: reconstructed volume file format
         :param cluster_config: cluster configuration in the case of a remote execution
-        :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.
+        :param 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
@@ -282,8 +287,8 @@ class _Reconstructor(_NabuBaseReconstructor):
         )
 
         results = {}
-        if self.advancement:
-            self.advancement.setMaxAdvancement(len(self.nabu_configs))
+        if self.advancement is not None:
+            self.advancement.total = len(self.nabu_configs)
         for var_value, config in self.nabu_configs.items():
             if self._cancelled:
                 break
@@ -307,8 +312,8 @@ class _Reconstructor(_NabuBaseReconstructor):
                 process_name=self.process_name,
             )
             # specific treatment for cor: rename output files
-            if self.advancement:
-                self.advancement.increaseAdvancement(1)
+            if self.advancement is not None:
+                self.advancement.update()
         return results
 
     def _format_file_prefix(self, file_prefix, value):
@@ -395,9 +400,9 @@ class _Reconstructor(_NabuBaseReconstructor):
             dataset_params.update(config["dataset"])
         config["dataset"] = dataset_params
 
-        config["resources"] = utils.get_nabu_resources_desc(
-            scan=self.scan, workers=1, method="local"
-        )
+        config["resources"] = config.get("resources", {})
+        config["resources"]["method"] = "local"
+
         # force overwrite results
         if "output" not in config:
             config["output"] = {}
@@ -423,10 +428,10 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
     def __init__(
         self,
         nabu_config: dict,
-        axis: Union[str, NabuPlane],
+        axis: str | NabuPlane,
         cors: tuple,
         file_format,
-        slice_index: Union[int, str] = "middle",
+        slice_index: int | str = "middle",
         output_file_prefix_pattern=None,
         *args,
         **kwargs,
@@ -448,7 +453,7 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         return self.__cors
 
     @property
-    def slice_index(self) -> Union[int, str]:
+    def slice_index(self) -> int | str:
         return self.__slice_index
 
     @property
@@ -460,13 +465,13 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         config_to_dump: dict,
         config_file: str,
         file_format: str,
-        info: Optional[str],
+        info: str | None,
         process_name: str,
     ):
         """
         process provided configuration
 
-        :param str info:
+        :param info:
         """
         if self.dry_run is True or self.only_create_config_file():
             return ResultsRun(
@@ -494,22 +499,6 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         else:
             raise ValueError(f"{self.target} is not recognized as a valid target")
 
-    @staticmethod
-    def convert_cor_from_rel_to_abs(scan, cor):
-        if scan.dim_1 is not None:
-            return cor + scan.dim_1 / 2.0
-        else:
-            _logger.warning("enable to get image half width. Set it to 1024")
-            return cor + 1024
-
-    @staticmethod
-    def convert_cor_from_abs_to_rel(scan, cor):
-        if scan.dim_1 is not None:
-            return cor - scan.dim_1 / 2.0
-        else:
-            _logger.warning("enable to get image half width. Set it to 1024")
-            return cor - 1024
-
     def _run_nabu_multicor_locally(
         self,
         conf_file: str,
@@ -519,18 +508,20 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         """
         run locally nabu for a single configuration file.
 
-        :param str conf_file: path to the nabu .cfg file
-        :param str file_format: format of the generated file
-        :param dict config_to_dump: configuration saved in the .cfg as a dictionary
+        :param conf_file: path to the nabu .cfg file
+        :param file_format: format of the generated file
+        :param config_to_dump: configuration saved in the .cfg as a dictionary
         :return: results of the local run
-        :rtype: ResultsLocalRun
         """
         if not has_nabu:
             raise ImportError("Fail to import nabu")
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
 
         cor_in_nabu_ref = tuple(
-            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+            [
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                for cor in self.cors
+            ]
         )
         cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
         command = " ".join(
@@ -538,7 +529,7 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
                 sys.executable,
                 "-m",
                 settings.NABU_MULTICOR_PATH,
-                conf_file,  # input file
+                f"'{conf_file}'",  # input file
                 f"{slice_index}",  # slice
                 f"{cor_in_nabu_ref}",  # cor
             )
@@ -567,12 +558,15 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
             scan=self.scan,
             file_format=file_format,
             cors=[
-                self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                for cor in self.cors
             ],
         )
         # convert back from abs ref to rel ref
         recons_vol_identifiers = {
-            self.convert_cor_from_abs_to_rel(self.scan, cor): identifiers
+            absolute_pos_to_relative(
+                absolute_pos=cor, det_width=self.scan.dim_1
+            ): identifiers
             for cor, identifiers in recons_vol_identifiers.items()
         }
         return ResultsLocalRun(
@@ -595,7 +589,6 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
         Run a nabu reconstruction on slurm of a single configuration
 
         :return: results of the slurm run
-        :rtype: ResultSlurmRun
         """
         if not isinstance(conf_file, str):
             raise TypeError(f"conf_file is expected to be a strg not {type(conf_file)}")
@@ -623,7 +616,10 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
 
         slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
         cor_in_nabu_ref = tuple(
-            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+            [
+                relative_pos_to_absolute(relative_pos=cor, det_width=self.scan.dim_1)
+                for cor in self.cors
+            ]
         )
         cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
 
@@ -664,9 +660,9 @@ class _ReconstructorMultiCor(_NabuBaseReconstructor):
             dataset_params.update(config["dataset"])
         config["dataset"] = dataset_params
 
-        config["resources"] = utils.get_nabu_resources_desc(
-            scan=self.scan, workers=1, method="local"
-        )
+        config["resources"] = config.get("resources", {})
+        config["resources"]["method"] = "local"
+
         # force overwrite results
         if "output" not in config:
             config["output"] = {}

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

@@ -1,32 +1,4 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2020 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "26/10/2021"
-
+from __future__ import annotations
 
 import copy
 import functools
@@ -44,11 +16,11 @@ from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.slurm import is_slurm_available
 from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.process.reconstruction.nabu.utils import slice_index_to_int
-from tomwer.core.process.icat.gallery import (
-    IcatScreenshots,
-    deduce_dataset_gallery_location,
-)
+from tomwer.core.process.reconstruction.utils.cor import relative_pos_to_absolute
 from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.core.process.reconstruction.output import (
+    PROCESS_FOLDER_RECONSTRUCTED_SLICES,
+)
 
 try:
     from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
@@ -70,7 +42,7 @@ else:
     has_nabu = True
     _err_import_nabu = None
 
-from typing import Iterable, Optional, Union
+from typing import Iterable
 
 from nabu import version as nabu_version
 from nabu.pipeline.config import (
@@ -114,32 +86,30 @@ def run_slices_reconstruction(
     config: dict,
     dry_run: bool = False,
     advancement=None,
-    process_id=None,
-    instanciate_classes_only: bool = False,
+    process_id: int | None = None,
+    instantiate_classes_only: bool = False,
 ) -> tuple:
     """
     call nabu for a reconstruction on scan with the given configuration
 
-    :param TomwerScanBase scan: scan to reconstruct
-    :param dict config: configuration to run the reconstruction.
+    :param scan: scan to reconstruct
+    :param config: configuration to run the reconstruction.
                         Contains nabu reconstruction parameters and slurm cluster
-                        configruation if requested (key: `slurm-cluster`).
-    :param bool dry_run: do we want to run dry
-    :param bool local: do we want to run a local reconstruction
+                        configuration if requested (key: `slurm-cluster`).
+    :param dry_run: do we want to run dry
+    :param local: do we want to run a local reconstruction
     :param stderr: file to redirect stderr
     :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
+    :param process_id: optional process id
+    :param instantiate_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.
-             * stdouts: list of stdout of job reconstruction or job requests
-             * stderrs: list of stderr of job reconstruction or job requests
-             * final_configs: list of configurations submits to nabu
-             * future_scan: Optional[FutureTomwerScan] future scan containing futures pointing to job submited to the cluster.
-                            None if local reconstruction
-    :rtype: tuple
+        * all_succeed: bool, True if all the reconstruction succeed or if all job request succeed.
+        * stdouts: list of stdout of job reconstruction or job requests
+        * stderrs: list of stderr of job reconstruction or job requests
+        * final_configs: list of configurations submits to nabu
+        * future_scan: FutureTomwerScan | None future scan containing futures pointing to job submited to the cluster. None if local reconstruction
 
     Behavior: will clear the last slices reconstructed
     """
@@ -162,7 +132,10 @@ def run_slices_reconstruction(
     if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
         if "reconstruction" in config:
             # move the cor value to the nabu reference
-            cor_nabu_ref = scan.axis_params.relative_cor_value + scan.dim_1 / 2.0
+            cor_nabu_ref = relative_pos_to_absolute(
+                relative_pos=scan.axis_params.relative_cor_value,
+                det_width=scan.dim_1,
+            )
             config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
     _logger.info(f"set nabu reconstruction parameters to {scan}")
 
@@ -178,10 +151,10 @@ def run_slices_reconstruction(
     stdouts = []
     final_configs = []
     futures = []
-    instanciated_classes = []
+    instantiated_classes = []
     all_succeed = True
     if advancement is not None:
-        advancement.setMaxAdvancement(len(nabu_configurations))
+        advancement.total = len(nabu_configurations)
     scan.clear_latest_reconstructions()
     for nabu_configuration in nabu_configurations:
         l_config, slice_index = nabu_configuration
@@ -191,7 +164,7 @@ def run_slices_reconstruction(
             scan=scan,
             slice_index=slice_index,
             dry_run=dry_run,
-            instanciate_class_only=instanciate_classes_only,
+            instantiate_class_only=instantiate_classes_only,
             axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
         )
 
@@ -199,8 +172,8 @@ def run_slices_reconstruction(
         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)
+        elif instantiate_classes_only:
+            instantiated_classes.append(result)
             continue
         if slice_index is None:
             continue
@@ -229,10 +202,10 @@ def run_slices_reconstruction(
             all_succeed = all_succeed and result.success
 
         if advancement is not None:
-            advancement.increaseAdvancement(1)
+            advancement.update()
 
-    if instanciate_classes_only:
-        return instanciated_classes
+    if instantiate_classes_only:
+        return instantiated_classes
     if is_cluster_job:
         future_tomo_obj = FutureTomwerObject(
             tomo_obj=scan,
@@ -258,7 +231,7 @@ class NabuSlicesTask(
         "dry_run",
         "serialize_output_data",
     ),
-    output_names=("data", "nabu_params", "future_tomo_obj", "screenshots"),
+    output_names=("data", "nabu_params", "future_tomo_obj"),
 ):
     """
     Definition of the nabu reconstruction volume reconstruction process
@@ -321,10 +294,10 @@ class NabuSlicesTask(
                 scan=scan,
                 dry_run=self._dry_run,
                 process_id=self.process_id,
-                instanciate_classes_only=True,
+                instantiate_classes_only=True,
             )
         except Exception as e:
-            mess = f"Fail to instanciate slice reconstructor for {str(scan)}. Reason is {e}."
+            mess = f"Fail to instantiate slice reconstructor for {str(scan)}. Reason is {e}."
             _logger.processFailed(mess)
             ProcessManager().notify_dataset_state(
                 dataset=scan,
@@ -389,15 +362,6 @@ class NabuSlicesTask(
                 VolumeFactory.from_identifier_to_vol_urls(rec_identifier)
             )
 
-        self.outputs.screenshots = IcatScreenshots(
-            data_dir=deduce_dataset_gallery_location(scan),
-            screenshots={
-                os.path.splitext(os.path.basename(url.file_path()))[0]: url
-                for url in volume_urls
-            },
-            scan=scan,
-        )
-
         process_index = scan.pop_process_index()
         # update processes information / registration
         gc.collect()
@@ -470,15 +434,11 @@ class NabuSlicesTask(
         return self._dry_run
 
     @staticmethod
-    def get_process_frm_process_file(process_file, entry):
+    def get_process_frm_process_file(process_file: str, entry: str) -> dict:
         """
-        Read informations regarding the nabu process save in the
-        tomwer_process.h5 file
+        Read informations regarding the nabu process save in the tomwer_process.h5 file
 
-        :param process_file:
-        :param entry:
         :return: dictionary with the contain of the nabu process
-        :rtype:dict
         """
         if entry is None:
             with open_hdf5(process_file) as h5f:
@@ -553,15 +513,13 @@ class NabuSlicesTask(
                 return h5py_read_dataset(latest_nabu_node[path])
 
 
-def interpret_tomwer_configuration(
-    config: dict, scan: Union[TomwerScanBase, None]
-) -> tuple:
+def interpret_tomwer_configuration(config: dict, scan: TomwerScanBase | None) -> tuple:
     """
     tomwer can 'mock' the nabu reconstruction to request more feature.
     Typical use case is that we can ask for reconstruction of several
     slices and not only the volume
 
-    :param dict config: tomwer configuration for nabu
+    :param config: tomwer configuration for nabu
     :param scan: requested if we want to get slices
     :return: tuple of tuples (nabu configuration, is slice)
     """
@@ -624,10 +582,10 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         scan: TomwerScanBase,
         config: dict,
         dry_run: bool,
-        slice_index: Union[int, str, None],
+        slice_index: int | str | None,
         axis: NabuPlane,
         target: Target,
-        cluster_config: Optional[dict],
+        cluster_config: dict | None,
         process_name: str,
         add_to_latest_reconstructions: bool = True,
     ) -> None:
@@ -657,6 +615,11 @@ class SingleSliceRunner(_NabuBaseReconstructor):
     def add_to_latest_reconstructions(self):
         return self._add_to_latest_reconstructions
 
+    @property
+    def processed_data_folder_name(self):
+        """return the specific processed folder name associated to this type of reconstruction."""
+        return PROCESS_FOLDER_RECONSTRUCTED_SLICES
+
     @docstring(_NabuBaseReconstructor)
     def only_create_config_file(self):
         return self.slice_index is None
@@ -690,9 +653,9 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 config_complete[key].update(self.config[key])
         config = config_complete
 
-        config["resources"] = utils.get_nabu_resources_desc(
-            scan=self.scan, workers=1, method="local"
-        )
+        config["resources"] = config.get("resources", {})
+        config["resources"]["method"] = "local"
+
         # force overwrite results
         if "output" not in config:
             config["output"] = {}
@@ -789,7 +752,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         pag,
         ctf,
         db,
-        slice_index: Union[str, int],
+        slice_index: str | int,
         axis: NabuPlane,
     ):
         axis = NabuPlane.from_value(axis)
@@ -853,12 +816,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
     def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """
 
-        :param TomwerScanBase scan: scan reconstructed
-        :param Union[None, int] slice_index: index of the slice reconstructed.
-                                            if None, we want to reconstruct the
-                                            entire volume
-        :param bool pag: is it a paganin reconstruction
-        :param int db: delta / beta parameter
+        :param pag: is it a paganin reconstruction
+        :param db: delta / beta parameter
         :return: basename of the file reconstructed (without any extension)
         """
         return self.get_file_basename_reconstruction(
@@ -875,30 +834,29 @@ def run_single_slice_reconstruction(
     scan,
     nabu_config,
     dry_run,
-    slice_index: Union[int, str, None],
-    process_id: Optional[int] = None,
-    cluster_config: Optional[dict] = None,
+    slice_index: int | str | None,
+    process_id: int | None = None,
+    cluster_config: dict | None = None,
     add_to_latest_reconstructions=True,
-    instanciate_class_only=False,
+    instantiate_class_only=False,
     axis: NabuPlane = NabuPlane.XY,
-) -> Optional[ResultsRun]:
+) -> ResultsRun | None:
     """
     # TODO: might need something like a context or an option "keep" slice in memory
 
     :param scan:
-    :param nabu_config: configruation of nabu process
-    :param cluster_config: configruation of cluster (slurm-cluster only for now)
+    :param nabu_config: configuration of nabu process
+    :param cluster_config: configuration of cluster (slurm-cluster only for now)
     :param dry_run:
-    :param Union[None,int, str] slice_index: slice index to reconstruct.
+    :param slice_index: slice index to reconstruct.
                                              If str should be "middle"
     :param local:
     :param stdout: file to redirect stdout
     :param stderr: file to redirect stderr
-    :param bool add_to_latest_reconstructions: if true add reconstructed slice to the latest reconstruction.
+    :param 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
+    :param instantiate_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]
     """
     # TODO: remove local from the function signature
     target = Target.SLURM if cluster_config not in ({}, None) else Target.LOCAL
@@ -928,7 +886,7 @@ def run_single_slice_reconstruction(
         add_to_latest_reconstructions=add_to_latest_reconstructions,
         process_name=process_name,
     )
-    if instanciate_class_only:
+    if instantiate_class_only:
         return slice_reconstructor
 
     try: