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

tomwer/core/log/logger.py

@@ -1,130 +0,0 @@
-# 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.
-#
-# ###########################################################################*/
-
-"""
-module dealing with log in color
-
-https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
-"""
-
-__author__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "22/09/2017"
-
-import logging
-import os
-from sys import platform
-
-from tomwer.core.log.processlog import (
-    PROCESS_ENDED_NAME,
-    PROCESS_FAILED_NAME,
-    PROCESS_INFORM_NAME,
-    PROCESS_SKIPPED_NAME,
-    PROCESS_STARTED_NAME,
-    PROCESS_SUCCEED_NAME,
-)
-
-# The background is set with 40 plus the number of the color, and the
-# foreground with 30
-
-# These are the sequences need to get colored ouput
-_RESET_SEQ = "\033[0m"
-_BOLD_SEQ = "\033[1m"
-
-_BLACK = "\033[30m"
-_RED = "\033[31m"
-_GREEN = "\033[32m"
-_YELLOW = "\033[33m"
-_BLUE = "\033[34m"
-_MAGENTA = "\033[35m"
-
-LOG_COLORS = {
-    "WARNING": _MAGENTA,
-    "INFO": _BLACK,
-    "DEBUG": _BLUE,
-    "CRITICAL": _YELLOW,
-    "ERROR": _RED,
-    PROCESS_SKIPPED_NAME: _MAGENTA,
-    PROCESS_ENDED_NAME: _BLACK,
-    PROCESS_INFORM_NAME: _BLACK,
-    PROCESS_STARTED_NAME: _BLACK,
-    PROCESS_FAILED_NAME: _RED,
-    PROCESS_SUCCEED_NAME: _GREEN,
-}
-
-
-def _formatter_message(message, use_color=True):
-    if use_color is True:
-        message = message.replace("$RESET", _RESET_SEQ).replace("$BOLD", _BOLD_SEQ)
-    else:
-        message = message.replace("$RESET", "").replace("$BOLD", "")
-    return message
-
-
-class _ColoredFormatter(logging.Formatter):
-    def __init__(self, msg):
-        logging.Formatter.__init__(self, msg)
-        if platform == "win32":
-            self.use_color = False
-        else:
-            self.use_color = os.environ.get("ORANGE_COLOR_STDOUT_LOG", "True") == "True"
-
-    def format(self, record):
-        levelname = record.levelname
-        if self.use_color is True and levelname in LOG_COLORS:
-            levelname_color = LOG_COLORS[levelname] + levelname + _RESET_SEQ
-            record.levelname = levelname_color
-        record.asctime = self.formatTime(record, self.datefmt)
-        return logging.Formatter.format(self, record)
-
-
-class TomwerLogger(logging.Logger):
-    """
-    Custom logger class with multiple destinations
-    """
-
-    FORMAT = (
-        "%(asctime)s [%(levelname)-16s] %(message)s [$BOLD%(name)-20s$RESET]"
-        "($BOLD%(filename)s$RESET:%(lineno)d)"
-    )
-
-    def __init__(self, name):
-        logging.Logger.__init__(self, name, logging.WARNING)
-        self.name = name
-        self.color_format = _formatter_message(
-            TomwerLogger.FORMAT,
-            use_color=os.environ.get("ORANGE_COLOR_STDOUT_LOG", "False") == "True",
-        )
-
-        color_formatter = _ColoredFormatter(self.color_format)
-
-        console = logging.StreamHandler()
-        console.setFormatter(color_formatter)
-
-        self.addHandler(console)
-        return
-
-    def __str__(self):
-        return self.name

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

@@ -1,74 +0,0 @@
-# # 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/06/2021"
-
-
-# import os
-# import shutil
-# import tempfile
-# import unittest
-
-# from tomwer.core.process.control.volumesymlink import VolumeSymbolicLinkTask
-# from tomwer.core.scan.edfscan import EDFTomoScan
-# from tomwer.core.utils.scanutils import MockEDF
-
-
-# class TestVolumeSymbolicLink(unittest.TestCase):
-#     """Simple test of the VolumeSymbolicLink"""
-
-#     def setUp(self) -> None:
-#         self._scan_folder = tempfile.mkdtemp()
-#         self._output_folder = tempfile.mkdtemp()
-#         MockEDF.fastMockAcquisition(self._scan_folder)
-#         MockEDF.mockReconstruction(self._scan_folder, nRecons=2, nPagRecons=2)
-#         self._scan = EDFTomoScan(self._scan_folder)
-#         # here we simply estimate that the slice reconstruction will be
-#         # volume reconstruction but the mechanism is the same.
-#         self._scan.set_latest_vol_reconstructions(self._scan.get_reconstructions_urls())
-
-#     def tearDown(self) -> None:
-#         for folder in (self._scan_folder, self._output_folder):
-#             shutil.rmtree(folder)
-
-#     def test(self):
-#         """simple test that the creation of a symbolic link works"""
-#         vlink_process = VolumeSymbolicLinkTask(
-#             inputs={
-#                 "data": self._scan,
-#                 "serialize_output_data": False,
-#                 "output_type": "static",
-#                 "output_folder": self._output_folder,
-#             }
-#         )
-#         self.assertEqual(len(os.listdir(self._output_folder)), 0)
-#         vlink_process.run()
-#         self.assertEqual(len(os.listdir(self._output_folder)), 4)
-
-#         self.assertTrue(isinstance(vlink_process.program_name(), str))
-#         self.assertTrue(isinstance(vlink_process.program_version(), str))
-#         self.assertTrue(isinstance(vlink_process.definition(), str))

tomwer/core/process/control/tomoobjserie.py

@@ -1,12 +0,0 @@
-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/volumesymlink.py

@@ -1,200 +0,0 @@
-# # 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.abspath(scan.path), output_folder)
-#                     )
-#         elif output_type is OutputType.ONE_LEVEL_UPPER:
-#             output_folder = os.path.abspath(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/icat/createscreenshots.py

@@ -1,100 +0,0 @@
-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,
-            )