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

tomwer/core/process/control/test/test_volume_link.py

@@ -33,7 +33,7 @@ import shutil
 import tempfile
 import unittest
 
-from tomwer.core.process.control.volumesymlink import VolumeSymbolicLinkProcess
+from tomwer.core.process.control.volumesymlink import VolumeSymbolicLinkTask
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.utils.scanutils import MockEDF
 
@@ -57,9 +57,10 @@ class TestVolumeSymbolicLink(unittest.TestCase):
 
     def test(self):
         """simple test that the creation of a symbolic link works"""
-        vlink_process = VolumeSymbolicLinkProcess(inputs={"data": self._scan})
-        vlink_process.set_configuration(
-            {
+        vlink_process = VolumeSymbolicLinkTask(
+            inputs={
+                "data": self._scan,
+                "serialize_output_data": False,
                 "output_type": "static",
                 "output_folder": self._output_folder,
             }

tomwer/core/process/control/timer.py

@@ -35,11 +35,17 @@ from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
+from silx.utils.deprecation import deprecated_warning, deprecated
 
 _logger = logging.getLogger(__name__)
 
 
-class Timer(Task, input_names=("data",), output_names=("data",)):
+class TimerTask(
+    Task,
+    input_names=("data", "wait"),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
+):
     """
     Simple timer / time out - function
     """
@@ -57,15 +63,16 @@ class Timer(Task, input_names=("data",), output_names=("data",)):
         )
         if inputs is None:
             inputs = {}
-        self.waiting_time = inputs.get("wait", 1)
 
     @property
+    @deprecated(replacement="task.wait", since_version="1.2")
     def waiting_time(self):
-        return self._waiting_time
+        return self.inputs.wait
 
     @waiting_time.setter
+    @deprecated(replacement="task.wait", since_version="1.2")
     def waiting_time(self, wait):
-        self._waiting_time = wait
+        self.inputs.wait = wait
 
     def run(self):
         scan = data_identifier_to_scan(self.inputs.data)
@@ -77,8 +84,22 @@ class Timer(Task, input_names=("data",), output_names=("data",)):
             raise TypeError(
                 f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
-        time.sleep(self.waiting_time)
-        if self._return_dict:
+        time.sleep(self.inputs.wait)
+        if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
             self.outputs.data = scan
+
+
+class Timer(TimerTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.control.timer.Timer",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="TimerTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/control/tomoobjserie.py

@@ -4,5 +4,9 @@ from ewokscore.task import Task as EwoksTask
 class _TomoobjseriePlaceHolder(
     EwoksTask, input_names=["serie"], output_names=["serie"]
 ):
+    """
+    task to define a tomography 'serie'
+    """
+
     def run(self):
         self.outputs.serie = self.inputs.serie

tomwer/core/process/control/volumeselector.py

@@ -6,5 +6,9 @@ from tomwer.core.utils.scanutils import data_identifier_to_scan
 class _VolumeSelectorPlaceHolder(
     EwoksTask, input_names=["volume"], output_names=["volume"]
 ):
+    """
+    task to select a volume or a set of volumes
+    """
+
     def run(self):
         self.outputs.volume = data_identifier_to_scan(self.inputs.volume)

tomwer/core/process/control/volumesymlink.py

@@ -32,6 +32,7 @@ import logging
 import os
 
 from silx.utils.enum import Enum as _Enum
+from silx.utils.deprecation import deprecated_warning, deprecated
 from tomoscan.factory import Factory
 from tomoscan.volumebase import VolumeBase
 
@@ -84,7 +85,12 @@ def create_volume_symbolic_link(scan: TomwerScanBase, output_folder: str):
                     os.symlink(src=src_file_path, dst=dst_file_path)
 
 
-class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data",)):
+class VolumeSymbolicLinkTask(
+    Task,
+    input_names=("data",),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data", "output_type", "output_folder"),
+):
     """
     Process class for volume symbolic link
     """
@@ -103,12 +109,25 @@ class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data
         self._output_folder = None
 
     @docstring(Task.set_configuration)
+    @deprecated(
+        reason="ewoksification",
+        replacement="task.inputs.output_type and task.inputs.output_folder",
+        since_version="1.2",
+    )
     def set_configuration(self, properties):
         if "output_type" in properties:
             self._output_type = OutputType.from_value(properties["output_type"])
         if "output_folder" in properties:
             self._output_folder = properties["output_folder"]
 
+    @deprecated(
+        reason="ewoksification",
+        replacement="task.inputs.output_type and task.inputs.output_folder",
+        since_version="1.2",
+    )
+    def get_configuration(self):
+        return super().get_configuration()
+
     @docstring(Task.program_name)
     @staticmethod
     def program_name():
@@ -133,29 +152,49 @@ class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data
                 f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
 
-        if self._output_type is OutputType.STATIC:
-            if self._output_folder is None:
+        output_type = OutputType.from_value(
+            self.get_input_value("output_type", self._output_type)
+        )
+        output_folder = self.get_input_value("output_folder", self._output_folder)
+        if output_type is OutputType.STATIC:
+            if output_folder is None:
                 raise ValueError(
                     "Manual setting of the output folder is "
                     "requested but None is provided."
                 )
             else:
-                output_folder = self._output_folder
                 if not os.path.isabs(output_folder):
                     os.path.abspath(
                         os.path.join(os.path.realpath(scan.path), output_folder)
                     )
-        elif self._output_type is OutputType.ONE_LEVEL_UPPER:
+        elif output_type is OutputType.ONE_LEVEL_UPPER:
             output_folder = os.path.realpath(scan.path)
             output_folder = os.path.abspath(
-                os.path.join(output_folder, self._output_type.value)
+                os.path.join(output_folder, output_type.value)
             )
         else:
-            raise ValueError(f"output type {self._output_type.value} is not managed")
+            raise ValueError(f"output type {output_type.value} is not managed")
         create_volume_symbolic_link(scan=scan, output_folder=output_folder)
-        self.outputs.data = scan
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan.to_dict()
+        else:
+            self.outputs.data = scan
 
     @docstring(Task.definition)
     @staticmethod
     def definition():
         return "Create a symbolic link to the volume folder"
+
+
+class VolumeSymbolicLinkProcess(VolumeSymbolicLinkTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.control.volumesymlink.VolumeSymbolicLinkProcess",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="VolumeSymbolicLinkTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/edit/darkflatpatch.py

@@ -31,11 +31,11 @@ __date__ = "04/11/2020"
 import nxtomomill.version
 from nxtomomill.utils import add_dark_flat_nx_file
 from silx.io.url import DataUrl
+from silx.utils.deprecation import deprecated_warning, deprecated
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
@@ -64,17 +64,18 @@ def apply_dark_flat_patch(scan: HDF5TomoScan, config: dict) -> TomwerScanBase:
     return scan
 
 
-class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
+class DarkFlatPatchTask(
+    Task,
+    input_names=("data", "configuration"),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
+):
     """
     Patch an existing NXtomo calling nxtomomill
     """
 
     def run(self):
         scan = data_identifier_to_scan(self.inputs.data)
-        if type(scan) is dict:
-            scan = ScanFactory.create_scan_object_frm_dict(scan)
-        else:
-            scan = scan
         if scan is None:
             return
         if not isinstance(scan, TomwerScanBase):
@@ -84,7 +85,9 @@ class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
         if not isinstance(scan, HDF5TomoScan):
             raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
 
-        config = self.get_configuration()
+        config = self.inputs.configuration
+        if not isinstance(config, dict):
+            raise TypeError(f"config is expected to be a dict. {type(config)} provided")
         apply_dark_flat_patch(scan=scan, config=config)
         keys = config.keys()
         for key in keys:
@@ -101,7 +104,10 @@ class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
                 process_index=scan.pop_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
 
     @staticmethod
     def program_name():
@@ -114,3 +120,38 @@ class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
     @staticmethod
     def definition():
         return "Apply patch for dark and references on a scan (TomwerScanBase)"
+
+    @deprecated(
+        since_version="1.2",
+        replacement="DarkFlatPatchTask.inputs.configuration",
+        reason="ewoksification",
+    )
+    def get_configuration(self):
+        """
+
+        :return: configuration of the process
+        :rtype: dict
+        """
+        return self.inputs.configuration
+
+    @deprecated(
+        since_version="1.2",
+        replacement="DarkFlatPatchTask.inputs.configuration",
+        reason="ewoksification",
+    )
+    def set_configuration(self, configuration: dict) -> None:
+        self.inputs.configuration = configuration
+
+
+class DarkFlatPatch(DarkFlatPatchTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.edit.darkflatpatch.DarkFlatPatch",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="DarkFlatPatchTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/edit/imagekeyeditor.py

@@ -34,11 +34,11 @@ import nxtomomill.version
 from nxtomomill.utils import change_image_key_control as _change_image_key_control
 from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomoscan.esrf.scan.hdf5scan import ImageKey as _ImageKey
+from silx.utils.deprecation import deprecated_warning, deprecated
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 _logger = logging.getLogger(__name__)
@@ -96,7 +96,16 @@ def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase
     return scan
 
 
-class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
+class ImageKeyEditorTask(
+    Task,
+    input_names=("data", "configuration"),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
+):
+    """
+    task to edit `image_key` field of an NXtomo ('data' input)
+    """
+
     def __init__(
         self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
     ):
@@ -107,14 +116,9 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
             node_attrs=node_attrs,
             execinfo=execinfo,
         )
-        self.set_configuration(inputs.get("image_key_edition", {}))
 
     def run(self):
         scan = data_identifier_to_scan(self.inputs.data)
-        if type(scan) is dict:
-            scan = ScanFactory.create_scan_object_frm_dict(scan)
-        else:
-            scan = scan
         if scan is None:
             return
         if not isinstance(scan, TomwerScanBase):
@@ -124,8 +128,10 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
         if not isinstance(scan, HDF5TomoScan):
             raise ValueError(f"input type of {scan}: {(type(scan))} is not managed")
 
-        change_image_key_control(scan=scan, config=self.get_configuration())
-        config = self.get_configuration()
+        config = self.inputs.configuration
+        if not isinstance(config, dict):
+            raise TypeError
+        change_image_key_control(scan=scan, config=config)
         modif_keys = list(config.get("modifications", {}).keys())
         new_modif = {}
         for key in modif_keys:
@@ -141,7 +147,10 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
                 process_index=scan.pop_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
 
     @staticmethod
     def program_name():
@@ -157,7 +166,10 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
 
 
 class ImageKeyUpgraderTask(
-    Task, input_names=("data", "operations"), output_names=("data",)
+    Task,
+    input_names=("data", "operations"),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
 ):
     """
     close to ImageKeyEditor but convert a full "family" of frame type to another
@@ -165,7 +177,7 @@ class ImageKeyUpgraderTask(
     """
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if not isinstance(scan, HDF5TomoScan):
             raise TypeError(f"scan is expected to be an instance of {HDF5TomoScan}")
         operations = self.inputs.operations
@@ -199,7 +211,10 @@ class ImageKeyUpgraderTask(
                 process_index=scan.pop_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
 
     @staticmethod
     def from_operation_to_config(
@@ -229,3 +244,38 @@ class ImageKeyUpgraderTask(
     @staticmethod
     def definition():
         return "Modify image keys on an NXTomo"
+
+    @deprecated(
+        since_version="1.2",
+        replacement="DarkFlatPatchTask.inputs.configuration",
+        reason="ewoksification",
+    )
+    def get_configuration(self):
+        """
+
+        :return: configuration of the process
+        :rtype: dict
+        """
+        return self.inputs.configuration
+
+    @deprecated(
+        since_version="1.2",
+        replacement="DarkFlatPatchTask.inputs.configuration",
+        reason="ewoksification",
+    )
+    def set_configuration(self, configuration: dict) -> None:
+        self.inputs.configuration = configuration
+
+
+class ImageKeyUpgrader(ImageKeyUpgraderTask):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.edit.imagekeyeditor.ImageKeyUpgrader",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="ImageKeyUpgraderTask",
+        )
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)

tomwer/core/process/reconstruction/axis/__init__.py

@@ -1,2 +1,2 @@
-from .axis import AxisProcess  # noqa F401
+from .axis import AxisTask  # noqa F401
 from .params import AxisRP  # noqa F401

tomwer/core/process/reconstruction/axis/axis.py

@@ -32,7 +32,6 @@ __date__ = "19/03/2019"
 import logging
 from typing import Optional, Union
 
-import nabu
 import numpy
 from nabu.estimation.cor import (
     CenterOfRotation,
@@ -41,8 +40,10 @@ from nabu.estimation.cor import (
     CenterOfRotationSlidingWindow,
 )
 from nabu.pipeline.estimators import SinoCORFinder
+from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
+from silx.utils.deprecation import deprecated_warning
 
 import tomwer.version
 from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
@@ -107,32 +108,27 @@ def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
     updating infos regarding flat and dark if needed
     """
     dataset_infos = scan.to_nabu_dataset_analyser()
-    if nabu.version > "2021.1.0" and isinstance(scan, HDF5TomoScan):
-        # since this version nabu does not the load of dark / flat mean/median
-        # directly in the function but outside. So we need an extra call to
-        # update_dataset_info_flats_darks
-        import inspect
-
-        from nabu.resources.nxflatfield import update_dataset_info_flats_darks
-
-        # processes_file has been removed in a minor release. safer to inspect if is needed or not
-        # should be removed on release 1.1 of tomwer I guess
-        if (
-            "processes_file"
-            in inspect.signature(update_dataset_info_flats_darks).parameters
-        ):
-            update_dataset_info_flats_darks(  # pylint: disable=E1123
-                dataset_infos,
-                processes_file=scan.get_relative_file(
-                    "nabu_processes.h5", with_dataset_prefix=True
-                ),
-                flatfield_mode=None,
-            )
-        else:
+    if isinstance(scan, HDF5TomoScan):
+        try:
             update_dataset_info_flats_darks(
                 dataset_infos,
                 flatfield_mode=None,
             )
+        except ValueError as exception:
+            # nabu raise an error if no darks / flats set. But this can make sense at this stage if the NXtomo has no
+            # raw dark / flat and is already normalized. In this case only fire a warning
+            if (
+                scan.reduced_darks is not None
+                and len(scan.reduced_darks) > 0
+                and scan.reduced_flats is not None
+                and len(scan.reduced_flats) > 0
+            ):
+                raise exception
+            else:
+                _logger.warning(
+                    "Fail to update nabu dataset info flats and darks. Expected if the dataset contains already normalized projections"
+                )
+
     return dataset_infos
 
 
@@ -304,7 +300,7 @@ def compute_scan_cor_nabu_growing_window(scan):
     :return: Union[float, None]
     """
     if not scan.axis_params.use_sinogram:
-        radio_1, radio_2 = AxisProcess.get_inputs(scan=scan)
+        radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
         if radio_1 is None or radio_2 is None:
             raise NoAxisUrl("Unable to find projections for nabu axis calculation")
     else:
@@ -417,7 +413,7 @@ def compute_scan_cor_nabu_sliding_window(scan):
     :return: Union[float, None]
     """
     if not scan.axis_params.use_sinogram:
-        radio_1, radio_2 = AxisProcess.get_inputs(scan=scan)
+        radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
         if radio_1 is None or radio_2 is None:
             raise NoAxisUrl("Unable to find projections for nabu axis calculation")
     else:
@@ -486,7 +482,7 @@ def compute_scan_cor_nabu_centered(scan):
 
     """
     assert scan.axis_params is not None
-    radio_1, radio_2 = AxisProcess.get_inputs(scan=scan)
+    radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
     if radio_1 is None or radio_2 is None:
         raise NoAxisUrl("Unable to find projections for nabu axis calculation")
 
@@ -540,7 +536,7 @@ def compute_scan_cor_nabu_global(scan):
 
     """
     assert scan.axis_params is not None
-    radio_1, radio_2 = AxisProcess.get_inputs(scan=scan)
+    radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
     if radio_1 is None or radio_2 is None:
         raise NoAxisUrl("Unable to find projections for nabu axis calculation")
 
@@ -578,8 +574,12 @@ class NoAxisUrl(Exception):
     pass
 
 
-class AxisProcess(
-    Task, SuperviseProcess, input_names=("data",), output_names=("data",)
+class AxisTask(
+    Task,
+    SuperviseProcess,
+    input_names=("data",),
+    output_names=("data",),
+    optional_input_names=("serialize_output_data",),
 ):
     """
     Process used to compute the center of rotation of a scan
@@ -677,6 +677,7 @@ class AxisProcess(
         """
         scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
+            self.outputs.data = None
             return
 
         if isinstance(scan, TomwerScanBase):
@@ -711,7 +712,11 @@ class AxisProcess(
         finally:
             if cor != "...":
                 self._process_end(scan, cor=cor, error=error)
-        self.outputs.data = scan_res
+
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan_res.to_dict()
+        else:
+            self.outputs.data = scan_res
 
     def _process_end(self, scan, cor, error=None):
         assert isinstance(scan, TomwerScanBase)
@@ -792,7 +797,7 @@ class AxisProcess(
     @staticmethod
     def get_inputs(scan):
         assert isinstance(scan, TomwerScanBase)
-        radio_1, radio_2 = AxisProcess.get_inputs_urls(scan=scan)
+        radio_1, radio_2 = AxisTask.get_inputs_urls(scan=scan)
         if radio_1 and radio_2:
             mess = " ".join(
                 ("input radios are", radio_1.url.path(), "and", radio_2.url.path())
@@ -856,7 +861,7 @@ class AxisProcess(
 
         :param TomwerScanBase scan: scan for which we want to compute the axis
                               position.
-        :return: scan as a TomoBase or a dict if _return_dict activated
+        :return: scan as a TomoBase or a dict if serialize_output_data activated
         """
         _logger.info("compute center of rotation for %s" % scan.path)
         try:
@@ -884,10 +889,7 @@ class AxisProcess(
                 f"Compute axis position ({r_cor_value}) with {method} for {scan_name}"
             )
             _logger.info(mess)
-        if self._return_dict:
-            return scan.to_dict()
-        else:
-            return scan
+        return scan
 
     def setMode(self, mode, value):
         if mode is AxisMode.manual:
@@ -952,9 +954,7 @@ class AxisProcess(
         """
         if entry is None:
             with HDF5File(process_file, "r", swmr=True) as h5f:
-                entries = AxisProcess._get_process_nodes(
-                    root_node=h5f, process=AxisProcess
-                )
+                entries = AxisTask._get_process_nodes(root_node=h5f, process=AxisTask)
                 if len(entries) == 0:
                     _logger.info("unable to find a Axis process in %s" % process_file)
                     return None
@@ -965,8 +965,8 @@ class AxisProcess(
                     _logger.info("take %s as default entry" % entry)
 
         with HDF5File(process_file, "r", swmr=True) as h5f:
-            axis_nodes = AxisProcess._get_process_nodes(
-                root_node=h5f[entry], process=AxisProcess
+            axis_nodes = AxisTask._get_process_nodes(
+                root_node=h5f[entry], process=AxisTask
             )
             index_to_path = {}
             for key, index in axis_nodes.items():
@@ -996,3 +996,23 @@ class AxisProcess(
                     else:
                         res = h5py_read_dataset(results_node["center_of_rotation"])
             return res
+
+
+class AxisProcess(AxisTask):
+    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.axis.axis.AxisProcess",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="AxisTask",
+        )
+        super().__init__(process_id, varinfo, inputs, node_id, node_attrs, execinfo)