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

tomwer/core/process/control/volumesymlink.py

@@ -1,200 +1,200 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 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__ = "16/11/2020"
-
-
-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
-
-import tomwer.version
-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 tomwer.utils import docstring
-
-_logger = logging.getLogger(__name__)
-
-
-class OutputType(_Enum):
-    STATIC = "static"
-    ONE_LEVEL_UPPER = "../volume"
-
-
-def create_volume_symbolic_link(scan: TomwerScanBase, output_folder: str):
-    """
-    Create a symbolic link for each volume reconstructed of `scan`
-
-    :param TomwerScanBase scan:
-    :param str output_folder:
-    """
-    if scan.latest_vol_reconstructions is None:
-        _logger.info("No volume reconstructed found")
-        return
-    if not os.path.exists(output_folder):
-        os.makedirs(output_folder)
-    for volume_url in scan.latest_vol_reconstructions:
-        volume = Factory.create_tomo_object_from_identifier(volume_url)
-        assert isinstance(volume, VolumeBase)
-        volume_files = set(
-            list(volume.browse_data_files()) + list(volume.browse_metadata_files()),
-        )
-        for src_file_path in volume_files:
-            if src_file_path is not None:
-                dst_file_path = os.path.join(
-                    output_folder, os.path.basename(src_file_path)
-                )
-                if os.path.exists(dst_file_path):
-                    _logger.info(
-                        "{} already exists. Cannot create a symbolic link on it"
-                    )
-                else:
-                    print(
-                        "src_file is", src_file_path, "dst_file_path is", dst_file_path
-                    )
-                    os.symlink(src=src_file_path, dst=dst_file_path)
-
-
-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
-    """
-
-    def __init__(
-        self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
-    ):
-        super().__init__(
-            varinfo=varinfo,
-            inputs=inputs,
-            node_id=node_id,
-            node_attrs=node_attrs,
-            execinfo=execinfo,
-        )
-        self._output_type = OutputType.ONE_LEVEL_UPPER
-        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():
-        return "tomwer_volume_symlink"
-
-    @docstring(Task.program_version)
-    @staticmethod
-    def program_version():
-        return tomwer.version.version
-
-    @docstring(Task.run)
-    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):
-            raise TypeError(
-                f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
-            )
-
-        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:
-                if not os.path.isabs(output_folder):
-                    os.path.abspath(
-                        os.path.join(os.path.realpath(scan.path), output_folder)
-                    )
-        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, output_type.value)
-            )
-        else:
-            raise ValueError(f"output type {output_type.value} is not managed")
-        create_volume_symbolic_link(scan=scan, output_folder=output_folder)
-        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)
+# # coding: utf-8
+# # /*##########################################################################
+# #
+# # Copyright (c) 2016-2017 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__ = "16/11/2020"
+
+
+# import logging
+# import os
+
+# from silx.utils.enum import Enum as _Enum
+# from tomwer.core.utils.deprecation import deprecated_warning, deprecated
+# from tomoscan.factory import Factory
+# from tomoscan.volumebase import VolumeBase
+
+# import tomwer.version
+# 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 tomwer.utils import docstring
+
+# _logger = logging.getLogger(__name__)
+
+
+# class OutputType(_Enum):
+#     STATIC = "static"
+#     ONE_LEVEL_UPPER = "../volume"
+
+
+# def create_volume_symbolic_link(scan: TomwerScanBase, output_folder: str):
+#     """
+#     Create a symbolic link for each volume reconstructed of `scan`
+
+#     :param TomwerScanBase scan:
+#     :param str output_folder:
+#     """
+#     if scan.latest_vol_reconstructions is None:
+#         _logger.info("No volume reconstructed found")
+#         return
+#     if not os.path.exists(output_folder):
+#         os.makedirs(output_folder)
+#     for volume_url in scan.latest_vol_reconstructions:
+#         volume = Factory.create_tomo_object_from_identifier(volume_url)
+#         assert isinstance(volume, VolumeBase)
+#         volume_files = set(
+#             list(volume.browse_data_files()) + list(volume.browse_metadata_files()),
+#         )
+#         for src_file_path in volume_files:
+#             if src_file_path is not None:
+#                 dst_file_path = os.path.join(
+#                     output_folder, os.path.basename(src_file_path)
+#                 )
+#                 if os.path.exists(dst_file_path):
+#                     _logger.info(
+#                         "{} already exists. Cannot create a symbolic link on it"
+#                     )
+#                 else:
+#                     print(
+#                         "src_file is", src_file_path, "dst_file_path is", dst_file_path
+#                     )
+#                     os.symlink(src=src_file_path, dst=dst_file_path)
+
+
+# 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
+#     """
+
+#     def __init__(
+#         self, varinfo=None, inputs=None, node_id=None, node_attrs=None, execinfo=None
+#     ):
+#         super().__init__(
+#             varinfo=varinfo,
+#             inputs=inputs,
+#             node_id=node_id,
+#             node_attrs=node_attrs,
+#             execinfo=execinfo,
+#         )
+#         self._output_type = OutputType.ONE_LEVEL_UPPER
+#         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():
+#         return "tomwer_volume_symlink"
+
+#     @docstring(Task.program_version)
+#     @staticmethod
+#     def program_version():
+#         return tomwer.version.version
+
+#     @docstring(Task.run)
+#     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):
+#             raise TypeError(
+#                 f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
+#             )
+
+#         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:
+#                 if not os.path.isabs(output_folder):
+#                     os.path.abspath(
+#                         os.path.join(os.path.realpath(scan.path), output_folder)
+#                     )
+#         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, output_type.value)
+#             )
+#         else:
+#             raise ValueError(f"output type {output_type.value} is not managed")
+#         create_volume_symbolic_link(scan=scan, output_folder=output_folder)
+#         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,24 +31,24 @@ __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.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
 
 
-def apply_dark_flat_patch(scan: HDF5TomoScan, config: dict) -> TomwerScanBase:
+def apply_dark_flat_patch(scan: NXtomoScan, config: dict) -> TomwerScanBase:
     """
 
     :param scan:
     :param config:
     :return:
     """
-    if not isinstance(scan, HDF5TomoScan):
+    if not isinstance(scan, NXtomoScan):
         raise ValueError(
-            f"Dark and flat patch only manage HDF5TomoScan and not {type(scan)}"
+            f"Dark and flat patch only manage NXtomoScan and not {type(scan)}"
         )
     if config is None:
         return scan
@@ -82,7 +82,7 @@ class DarkFlatPatchTask(
             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

tomwer/core/process/edit/imagekeyeditor.py

@@ -32,12 +32,11 @@ 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 +44,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 +62,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:
@@ -125,7 +124,7 @@ 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
@@ -178,8 +177,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")
@@ -204,7 +203,7 @@ class ImageKeyUpgraderTask(
                 process_file=scan.process_file,
                 entry=scan.entry,
                 configuration={
-                    _ImageKey.from_value(key).value: _ImageKey.from_value(value).value
+                    ImageKey.from_value(key).value: ImageKey.from_value(value).value
                     for key, value in operations.items()
                 },
                 results={},
@@ -218,13 +217,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,
+            )