tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/core/process/edit/imagekeyeditor.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "26/10/2020"
 
 
+import copy
 import logging
 
 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 nxtomo.nxobject.nxdetector import ImageKey
+from tomwer.core.utils.deprecation import deprecated_warning, deprecated
 
 from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 
@@ -45,14 +45,14 @@ _logger = logging.getLogger(__name__)
 
 
 IMAGE_KEYS = {
-    "projection": _ImageKey.PROJECTION,
-    "invalid": _ImageKey.INVALID,
-    "dark": _ImageKey.DARK_FIELD,
-    "flat": _ImageKey.FLAT_FIELD,
+    "projection": ImageKey.PROJECTION,
+    "invalid": ImageKey.INVALID,
+    "dark": ImageKey.DARK_FIELD,
+    "flat": ImageKey.FLAT_FIELD,
 }
 
 
-def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase:
+def change_image_key_control(scan: NXtomoScan, config: dict) -> TomwerScanBase:
     """
 
     :param scan:
@@ -63,9 +63,9 @@ def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase
     """
     if scan is None:
         return
-    elif not isinstance(scan, HDF5TomoScan):
+    elif not isinstance(scan, NXtomoScan):
         raise ValueError(
-            f"Image key control only handle HDF5TomoScan and not {type(scan)}"
+            f"Image key control only handle NXtomoScan and not {type(scan)}"
         )
 
     if "modifications" not in config:
@@ -84,7 +84,7 @@ def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase
             filter(lambda item: item[1] is image_key_type, modifications.items())
         )
         frame_indexes = tuple(frame_indexes_dict.keys())
-        _logger.warning(f"will modify {frame_indexes} to {image_key_type}")
+        _logger.info(f"will modify {frame_indexes} to {image_key_type}")
         _change_image_key_control(
             file_path=scan.master_file,
             entry=scan.entry,
@@ -125,28 +125,31 @@ class ImageKeyEditorTask(
             raise TypeError(
                 f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
-        if not isinstance(scan, HDF5TomoScan):
+        if not isinstance(scan, NXtomoScan):
             raise ValueError(f"input type of {scan}: {(type(scan))} is not managed")
 
         config = self.inputs.configuration
         if not isinstance(config, dict):
             raise TypeError
+        # apply configuration
         change_image_key_control(scan=scan, config=config)
         modif_keys = list(config.get("modifications", {}).keys())
+        # dump modifications to the tomwer processes file
+        # note: we need to cast image keys to str to save it
+        config = copy.deepcopy(config)
         new_modif = {}
         for key in modif_keys:
             value = config["modifications"][key]
             config["modifications"][str(key)] = value
         config["modifications"] = new_modif
-        with scan.acquire_process_file_lock():
-            self.register_process(
-                process_file=scan.process_file,
-                entry=scan.entry,
-                configuration=config,
-                results={},
-                process_index=scan.pop_process_index(),
-                overwrite=True,
-            )
+        self.register_process(
+            process_file=scan.process_file,
+            entry=scan.entry,
+            configuration=config,
+            results={},
+            process_index=scan.pop_process_index(),
+            overwrite=True,
+        )
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
@@ -178,8 +181,8 @@ class ImageKeyUpgraderTask(
 
     def run(self):
         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}")
+        if not isinstance(scan, NXtomoScan):
+            raise TypeError(f"scan is expected to be an instance of {NXtomoScan}")
         operations = self.inputs.operations
         if not isinstance(operations, dict):
             raise TypeError("operations is expected to be an dict")
@@ -199,18 +202,17 @@ class ImageKeyUpgraderTask(
 
         # apply modification using tomoscan
         change_image_key_control(scan=scan, config=configuration)
-        with scan.acquire_process_file_lock():
-            self.register_process(
-                process_file=scan.process_file,
-                entry=scan.entry,
-                configuration={
-                    _ImageKey.from_value(key).value: _ImageKey.from_value(value).value
-                    for key, value in operations.items()
-                },
-                results={},
-                process_index=scan.pop_process_index(),
-                overwrite=True,
-            )
+        self.register_process(
+            process_file=scan.process_file,
+            entry=scan.entry,
+            configuration={
+                ImageKey.from_value(key).value: ImageKey.from_value(value).value
+                for key, value in operations.items()
+            },
+            results={},
+            process_index=scan.pop_process_index(),
+            overwrite=True,
+        )
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
@@ -218,13 +220,13 @@ class ImageKeyUpgraderTask(
 
     @staticmethod
     def from_operation_to_config(
-        scan: TomwerScanBase, from_image_key: _ImageKey, to_image_key: _ImageKey
+        scan: TomwerScanBase, from_image_key: ImageKey, to_image_key: ImageKey
     ):
         """
         retrieve frame indices to be updated
         """
-        from_image_key = _ImageKey.from_value(from_image_key)
-        to_image_key = _ImageKey.from_value(to_image_key)
+        from_image_key = ImageKey.from_value(from_image_key)
+        to_image_key = ImageKey.from_value(to_image_key)
 
         config = {}
         for i_frame, frame in enumerate(scan.frames):

tomwer/core/process/icat/createscreenshots.py

@@ -0,0 +1,100 @@
+import numpy
+from tomwer.core.process.task import Task
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.dictutils import concatenate_dict
+from tomwer.core.process.icat.screenshots import IcatScreenshots
+from tomwer.core.process.icat.gallery import deduce_dataset_gallery_location
+
+from processview.core.manager import DatasetState, ProcessManager
+
+
+def get_closest_projection(angle, angles_list):
+    idx_closest = numpy.argmin(numpy.abs(angles_list - angle))
+    return angles_list[idx_closest]
+
+
+def select_angles(angles_list: tuple, each_angle: int) -> tuple:
+    angles_list = sorted(angles_list)
+    if len(angles_list) > 0:
+        start_angle = angles_list[0]
+        stop_angle = angles_list[-1]
+        picked_angle = numpy.arange(start_angle, stop_angle + 1, step=each_angle)
+        return tuple(
+            [get_closest_projection(angle, angles_list) for angle in picked_angle]
+        )
+    else:
+        return tuple()
+
+
+class CreateRawDataScreenshotsTask(
+    Task,
+    input_names=("data",),  # screenshots as instance of :class:Screenshots
+    optional_input_names=(
+        "__process__",
+        "raw_projections_required",
+        "raw_projections_each",
+        "raw_darks_required",
+        "raw_flats_required",
+    ),
+    output_names=("screenshots",),
+):
+    """
+    simple task to create screenshots from raw data
+    One raw projection will be picked each 'raw_projections_each' angle (expected in degree)
+    If 'with_flat' then will pick the first flat of each serie
+    If 'with_dark' then will pick the first dark of each serie
+    """
+
+    def run(self):
+        process = self.get_input_value("__process__", None)
+        scan = self.inputs.data
+        if not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"scan is expected to be an instance of {TomwerScanBase}. Get {type(scan)} instead"
+            )
+        if process is not None:
+            ProcessManager().notify_dataset_state(
+                dataset=scan,
+                process=process(),
+                state=DatasetState.ON_GOING,
+            )
+
+        raw_projections_required = self.get_input_value(
+            "raw_projections_required", True
+        )
+        proj_each = self.get_input_value("raw_projections_each", 90)
+        raw_flats_required = self.get_input_value("raw_flats_required", True)
+        raw_darks_required = self.get_input_value("raw_darks_required", True)
+
+        screenshots_urls = {}
+        # dict with screenshot name as key and DataUrl as value
+        if raw_darks_required and len(scan.darks) > 0:
+            screenshots_urls["dark"] = next(iter(scan.darks.values()))
+        if raw_flats_required and len(scan.flats) > 0:
+            screenshots_urls["flat"] = next(iter(scan.flats.values()))
+        if raw_projections_required:
+            projections = scan.projections_with_angle()
+            picked_angles = select_angles(
+                angles_list=sorted(projections.keys()),
+                each_angle=proj_each,
+            )
+            screenshots_urls = concatenate_dict(
+                screenshots_urls,
+                {
+                    f"projection_{angle:.1f}": projections[angle]
+                    for angle in picked_angles
+                },
+            )
+
+        self.outputs.screenshots = IcatScreenshots(
+            data_dir=deduce_dataset_gallery_location(scan),
+            screenshots=screenshots_urls,
+            scan=scan,
+        )
+
+        if process is not None:
+            ProcessManager().notify_dataset_state(
+                dataset=scan,
+                process=process(),
+                state=DatasetState.SUCCEED,
+            )

tomwer/core/process/icat/gallery.py

@@ -0,0 +1,377 @@
+import logging
+import os
+from math import floor
+
+import numpy
+from nxtomomill.converter.hdf5.utils import PROCESSED_DATA_DIR_NAME, RAW_DATA_DIR_NAME
+from PIL import Image
+from silx.io.url import DataUrl
+from silx.utils.enum import Enum as _Enum
+from tomoscan.esrf.scan.utils import get_data
+from tomoscan.esrf.volume.hdf5volume import HDF5Volume
+from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
+
+from tomwer.io.utils.raw_and_processed_data import to_processed_data_path
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.process.task import Task
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.process.icat.screenshots import IcatScreenshots
+from tomwer.core.process.icat.publish import (
+    PublishProcessedDataFolderTask,
+    from_bliss_original_file_to_raw,
+)
+from processview.core.manager import DatasetState, ProcessManager
+
+_logger = logging.getLogger(__name__)
+
+PROPOSAL_GALLERY_DIR_NAME = "GALLERY"
+DATASET_GALLERY_DIR_NAME = "gallery"
+
+
+class OutputFormat(_Enum):
+    """possible output format to save screenshots"""
+
+    PNG = "png"
+    JPEG = "jpg"
+
+
+class Binning(_Enum):
+    ONE_BY_ONE = "1x1"
+    TWO_BY_TWO = "2x2"
+    FOUR_BY_FOUR = "4x4"
+    HEIGHT_BY_HEIGHT = "8x8"
+    SIXTEEN_BY_SIXTEEN = "16x16"
+    THIRTY_TWO_BY_THIRTY_TWO = "32x32"
+    SIXTY_FOUR_BY_SIXTY_FOUR = "64x64"
+    ONE_HUNDRED_TWENTY_HEIGHT_BY_ONE_HUNDRED_TWENTY_HEIGHT = "128x128"
+
+    @staticmethod
+    def _bin_data(data, binning):
+        if not isinstance(data, numpy.ndarray):
+            raise TypeError("data should be a numpy array")
+        if not data.ndim == 2:
+            raise ValueError("data is expected to be 2d")
+        binning = Binning.from_value(binning)
+        if binning is Binning.ONE_BY_ONE:
+            return data
+        elif binning is Binning.TWO_BY_TWO:
+            return data[::2, ::2]
+        elif binning is Binning.FOUR_BY_FOUR:
+            return data[::4, ::4]
+        elif binning is Binning.HEIGHT_BY_HEIGHT:
+            return data[::8, ::8]
+        elif binning is Binning.SIXTEEN_BY_SIXTEEN:
+            return data[::16, ::16]
+        elif binning is Binning.THIRTY_TWO_BY_THIRTY_TWO:
+            return data[::32, ::32]
+        elif binning is Binning.SIXTY_FOUR_BY_SIXTY_FOUR:
+            return data[::64, ::64]
+        else:
+            raise NotImplementedError
+
+
+def deduce_dataset_gallery_location(scan_obj: TomwerScanBase) -> str:
+    """
+    From scan path deduce the 'dataset' path to the gallery.
+    Warning: dataset gallery is different then the 'proposal' gallery
+    """
+    if not isinstance(scan_obj, TomwerScanBase):
+        raise TypeError(f"'scan_obj' is expected to be an instance of {TomwerScanBase}")
+
+    file_path = os.path.abspath(scan_obj.path)
+
+    split_path = file_path.split(os.sep)
+    # reverse it to find the lower level value of 'PROCESSED_DATA_DIR_NAME' or 'RAW_DATA_DIR_NAME' if by any 'chance' has several in the path
+    # then we will replace the 'lower one' in the string. This is where the GALLERY will be added
+    split_path = split_path[::-1]
+    # check if already contain in a "PROCESSED_DATA" directory
+    try:
+        index_processed_data = split_path.index(PROCESSED_DATA_DIR_NAME)
+    except ValueError:
+        pass
+        index_processed_data = None
+    try:
+        index_raw_data = split_path.index(RAW_DATA_DIR_NAME)
+    except ValueError:
+        # if the value is not in the list
+        index_raw_data = None
+
+    if index_processed_data is None and index_raw_data is None:
+        # if not in any "PROCESSED_DATA" or "RAW_DATA" directory
+        return scan_obj.get_relative_file(
+            file_name=DATASET_GALLERY_DIR_NAME, with_dataset_prefix=False
+        )
+    elif index_processed_data is not None and index_raw_data is not None:
+        if index_raw_data > index_processed_data:
+            # if PROCESSED_DATA lower in the path than RAW_DATA
+            split_path[index_processed_data] = RAW_DATA_DIR_NAME
+    # reorder path to original
+    split_path = list(split_path[::-1])
+    split_path.append(DATASET_GALLERY_DIR_NAME)
+    # move it to PPROCESSED_DATA when possible
+    path = os.sep.join(split_path)
+    path = to_processed_data_path(path)
+    return path
+
+
+def deduce_proposal_GALLERY_location(scan_obj: TomwerScanBase) -> str:
+    """
+    Policy: look if the scan_obj.path is in 'PROCESSED_DATA_DIR_NAME' or 'RAW_DATA_DIR_NAME' directories.
+    If find any (before any 'GALLERY_DIR_NAME' directory) replace it "GALLERY_DIR_NAME".
+    If none of those are found then create it at the same level as the scan
+
+    :param TomwerScanBase scan_obj: scan_obj for which we want the GALLERY directory
+    :return: gallery path (to save screeshots for example)
+    """
+    if not isinstance(scan_obj, TomwerScanBase):
+        raise TypeError(f"'scan_obj' is expected to be an instance of {TomwerScanBase}")
+
+    file_path = os.path.abspath(scan_obj.path)
+
+    split_path = file_path.split(os.sep)
+    # reverse it to find the lower level value of 'PROCESSED_DATA_DIR_NAME' or 'RAW_DATA_DIR_NAME' if by any 'chance' has several in the path
+    # then we will replace the 'lower one' in the string. This is where the GALLERY will be added
+    split_path = split_path[::-1]
+    # check if already contain in a "PROCESSED_DATA" directory
+    try:
+        index_processed_data = split_path.index(PROCESSED_DATA_DIR_NAME)
+    except ValueError:
+        pass
+        index_processed_data = None
+    try:
+        index_raw_data = split_path.index(RAW_DATA_DIR_NAME)
+    except ValueError:
+        # if the value is not in the list
+        index_raw_data = None
+
+    if index_processed_data is None and index_raw_data is None:
+        # if not in any "PROCESSED_DATA" or "RAW_DATA" directory
+        return scan_obj.get_relative_file(
+            file_name=PROPOSAL_GALLERY_DIR_NAME, with_dataset_prefix=False
+        )
+    elif index_processed_data is not None and index_raw_data is not None:
+        if index_raw_data > index_processed_data:
+            # if PROCESSED_DATA lower in the path than RAW_DATA
+            split_path[index_processed_data] = PROPOSAL_GALLERY_DIR_NAME
+        else:
+            # if RAW_DATA lower in the path than PROCESSED_DATA
+            split_path[index_raw_data] = PROPOSAL_GALLERY_DIR_NAME
+    elif index_raw_data is not None:
+        # if the path contains only PROCESSED_DATA or RAW_DATA (expected behavior for online acquistion)
+        split_path[index_raw_data] = PROPOSAL_GALLERY_DIR_NAME
+    else:
+        assert index_processed_data is not None, "index_processed_data is None"
+        split_path[index_processed_data] = PROPOSAL_GALLERY_DIR_NAME
+
+    # reorder path to original
+    split_path = split_path[::-1]
+    return os.sep.join(split_path)
+
+
+def select_screenshot_from_volume(volume: TomwerVolumeBase) -> dict:
+    """
+    return a subset of url for a volume.
+    Warning: this function will be called each time a nabu slice or a nabu volume is executer from orangecontrig.
+    So it must stay 'low processing' function to avoid slowing down everything
+    """
+    if not isinstance(volume, TomwerVolumeBase):
+        raise TypeError(
+            f"volume is expected to be an instance of {TomwerVolumeBase}. Get {type(volume)}"
+        )
+
+    if isinstance(volume, VolumeSingleFrameBase):
+        volume_urls = tuple(volume.browse_data_urls())
+        # lets take the three equally spaced slices (3/6, 4/6 and 5/6)
+        n_slices = len(volume_urls)
+        # note: using a dict ensure to get a set of DataUrl in case an Url is used several time
+        # workaround: DataUrl is not hashable
+        screenshots = {
+            f"{os.path.splitext(os.path.basename(volume_urls[floor(i * n_slices / 6)].file_path()))}": volume_urls[
+                floor(i * n_slices / 6)
+            ]
+            for i in range(2, 5)
+        }
+        return screenshots
+    elif isinstance(volume, HDF5Volume):
+        volume_url = next(volume.browse_data_urls())
+        n_slices = volume.get_volume_shape()[0]
+        # note: using a dict ensure to get a set of DataUrl in case an Url is used several time
+        # workaround: DataUrl is not hashable
+        screenshots = {
+            f"{os.path.splitext(os.path.basename(volume_url.file_path()))[0]}_{floor(i / 6 * n_slices)}": DataUrl(
+                file_path=volume_url.file_path(),
+                data_path=volume_url.data_path(),
+                scheme="silx",
+                data_slice=floor(i / 6 * n_slices),
+            )
+            for i in range(2, 5)
+        }
+        return screenshots
+    else:
+        _logger.warning(
+            f"volume {type(volume)} does not allow to create screenshot for now"
+        )
+        return ()
+
+
+class SaveScreenshotsToGalleryTask(
+    Task,
+    input_names=("screenshots",),  # screenshots as instance of :class:Screenshots
+    optional_input_names=("format", "overwrite", "binning"),
+):
+    """simple task to do the binding between orange design and 'SaveScreenshotsTask'"""
+
+    def run(self):
+        if not isinstance(self.inputs.screenshots, IcatScreenshots):
+            raise TypeError(
+                f"'screenshots' is expected to be an instance of {IcatScreenshots}. get {type(self.inputs.screenshots)}"
+            )
+
+        inputs = self.inputs.screenshots.to_dict()
+        if self.get_input_value("overwrite", None) is not None:
+            inputs["overwrite"] = self.inputs.overwrite
+        if self.get_input_value("format", None) is not None:
+            inputs["format"] = self.inputs.format
+        if self.get_input_value("binning", None) is not None:
+            inputs["binning"] = self.inputs.binning
+        task = SaveScreenshotsTask(
+            inputs=inputs,
+        )
+        task.run()
+
+
+class SaveScreenshotsTask(
+    Task,
+    input_names=("screenshots_as_dict", "output_dir"),
+    optional_input_names=("format", "overwrite", "binning"),
+):
+    """Task which save a set of screenshot to the output_dir under required format"""
+
+    def run(self):
+        format = OutputFormat.from_value(
+            self.get_input_value("format", OutputFormat.PNG)
+        )
+        overwrite = self.get_input_value("overwrite", False)
+        binning = self.get_input_value("binning", Binning.ONE_BY_ONE)
+
+        os.makedirs(self.inputs.output_dir, exist_ok=True)
+        for screenshot_name, data_url in self.inputs.screenshots_as_dict.items():
+            if not isinstance(data_url, DataUrl):
+                raise TypeError("screenshot values are expected to DataUrl")
+            data = get_data(data_url)
+            if not isinstance(data, numpy.ndarray) and data.ndim != 2:
+                raise TypeError("screenshot are expected to be 2D numpy arrays")
+            if not isinstance(screenshot_name, str):
+                raise TypeError(
+                    f"screenshot keys are expected to be str. Get {type(screenshot_name)}"
+                )
+
+            if data.ndim == 3 and data.shape[0] == 1:
+                data = data.reshape(data.shape[1:])
+            elif data.ndim != 2:
+                raise ValueError(
+                    f"only 2D grayscale image are handled. Get {data.shape}"
+                )
+            # if qt is available use it as this is simpler and more powerful
+            # clamp data in 0-256
+            data = data.astype(numpy.float32)
+            data = Binning._bin_data(data=data, binning=binning)
+            data *= 255.0 / data.max()
+
+            # do a rescale else use qt instead
+            img = Image.fromarray(data, mode=None)
+            img = img.convert("L")
+            output_file = os.path.join(
+                self.inputs.output_dir,
+                ".".join([screenshot_name, format.value]),
+            )
+            if not overwrite and os.path.exists(output_file):
+                raise OSError(f"File already exists ({output_file})")
+            img.save(output_file)
+
+
+class SaveToGalleryAndPublishTask(
+    Task,
+    input_names=(
+        "screenshots",
+        "beamline",
+        "dataset",
+        "proposal",
+        "format",
+    ),
+    optional_input_names=(
+        "dry_run",
+        "__process__",
+    ),
+):
+    def __init__(
+        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+    ):
+        super().__init__(varinfo, inputs, node_id, node_attrs, execinfo)
+        self._process = self.get_input_value("__process__", None)
+        self._task_save = SaveScreenshotsToGalleryTask(
+            inputs=inputs,
+        )
+
+        scan = self.inputs.screenshots.scan
+        if isinstance(scan, EDFTomoScan):
+            raise TypeError(
+                "scan is an EDFTomoScan. Not handled for publishing processed data to icat"
+            )
+        raw = from_bliss_original_file_to_raw(scan.get_bliss_orginal_files())
+
+        path = self.inputs.screenshots.data_dir
+        # path = os.path.dirname(self.inputs.screenshots.data_dir)
+
+        self._task_publish = PublishProcessedDataFolderTask(
+            inputs={
+                "beamline": self.inputs.beamline,
+                "dataset": self.inputs.dataset,
+                "proposal": self.inputs.proposal,
+                "path": path,  # must be the dataset path
+                "raw": raw,
+                "dry_run": self.get_input_value("dry_run", False),
+                "metadata": self.inputs.screenshots.metadata,
+            },
+        )
+
+    def run(self):
+        if self._process is not None:
+            ProcessManager().notify_dataset_state(
+                dataset=self.inputs.screenshots.scan,
+                process=self._process(),
+                state=DatasetState.ON_GOING,
+            )
+        # save screenshots to gallery
+        try:
+            self._task_save.run()
+        except Exception as e:
+            if self._process is not None:
+                ProcessManager().notify_dataset_state(
+                    dataset=self.inputs.screenshots.scan,
+                    process=self._process(),
+                    state=DatasetState.FAILED,
+                    details=str(e),
+                )
+            raise e
+
+        # publication
+        try:
+            self._task_publish.run()
+        except Exception as e:
+            if self._process is not None:
+                ProcessManager().notify_dataset_state(
+                    dataset=self.inputs.screenshots.scan,
+                    process=self._process(),
+                    state=DatasetState.FAILED,
+                    details=str(e),
+                )
+            raise e
+        else:
+            if self._process is not None:
+                ProcessManager().notify_dataset_state(
+                    dataset=self.inputs.screenshots.scan,
+                    process=self._process(),
+                    state=DatasetState.SUCCEED,
+                )

tomwer/core/process/icat/icatbase.py

@@ -0,0 +1,36 @@
+import weakref
+from tomwer.core.scan.scanbase import TomwerScanBase
+
+
+class IcatProcessedDataBase:
+    """
+    Container class to get all the information about processed data to be publish
+    """
+
+    def __init__(self, data_dir: str, scan: TomwerScanBase) -> None:
+        self._output_dir = data_dir
+        # output dir for the screenshots. The default is expected to be provided by the task creating the screenshot.
+        # it can be overwrite by the 'SaveScreenshotTask' if an output dir is provided
+        self._scan = weakref.ref(scan) if scan is not None else scan
+
+    @property
+    def data_dir(self):
+        return self._output_dir
+
+    @property
+    def scan(self):
+        return self._scan() if self._scan is not None else None
+
+    @property
+    def metadata(self) -> dict:
+        scan = self.scan
+        if scan is not None:
+            return scan.build_icat_metadata()
+        else:
+            return {}
+
+    def to_dict(self):
+        return {
+            "output_dir": self.data_dir,
+            "icat_metadata": self.metadata,
+        }