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

tomwer/gui/edit/nxtomoeditor.py

@@ -1,25 +1,15 @@
+from __future__ import annotations
+
 import logging
 import weakref
-from typing import Optional
-from functools import lru_cache as cache
 
-import h5py
 import numpy
 from silx.gui import qt
-from silx.io.utils import h5py_read_dataset
-from silx.io.dictdump import dicttonx
-
-from tomoscan.io import HDF5File
-from nxtomo.paths.nxtomo import get_paths as get_nexus_paths
-from nxtomo.nxobject.nxdetector import ImageKey
-from nxtomo.nxobject.nxdetector import FOV
-from nxtomo.nxobject.nxtransformations import NXtransformations
-from nxtomo.utils.transformation import (
-    build_matrix,
-    UDDetTransformation,
-    LRDetTransformation,
-)
 
+from nxtomo.nxobject.nxdetector import ImageKey, FOV
+from nxtomo.utils.transformation import build_matrix
+
+from tomwer.core.process.edit.nxtomoeditor import NXtomoEditorTask, NXtomoEditorKeys
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui.utils.scandescription import ScanNameLabelAndShape
@@ -30,6 +20,10 @@ _logger = logging.getLogger(__name__)
 
 
 class NXtomoEditorDialog(qt.QDialog):
+    """
+    Dialog embedding instances of NXtomoEditor and NXtomoProxyWarmer
+    """
+
     def __init__(self, parent=None, hide_lockers=True) -> None:
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
@@ -46,33 +40,40 @@ class NXtomoEditorDialog(qt.QDialog):
         self.layout().addWidget(self._buttons)
 
     # expose API
-    def setScan(self, scan):
+    def setScan(self, scan: NXtomoScan) -> None:
         self.mainWidget.setScan(scan)
         self._warmer.setScan(scan)
 
-    def overwriteNXtomo(self):
-        self.mainWidget.overwriteNXtomo()
-
     def hasLockField(self) -> bool:
         return self.mainWidget.hasLockField()
 
     def getConfiguration(self) -> dict:
         return self.mainWidget.getConfiguration()
 
-    def setConfiguration(self, config):
+    def setConfiguration(self, config: dict) -> None:
         self.mainWidget.setConfiguration(config)
 
+    def getConfigurationForTask(self) -> dict:
+        return self.mainWidget.getConfigurationForTask()
+
 
 class NXtomoEditor(qt.QWidget):
     """
-    class to edit parameter of a NXtomo.
+    Widget to edit a set of field from a NXtomo.
     The preliminary goal is to let the user define pixel / voxel position and x and z positions
     in order to simplify stitching down the line
 
-    As energy and scan range was also often requested this part is also editable (user bonus ^^)
+    As energy and field of view was also often requested this part is also editable.
+
+    Each field contains a widget to define it values and a LockButton. The LockButton can be used to automate the
+    processing.
+
+    When the scan to edit is set each field widget will be updated **at the condition** the field is not locked.
+    Else existing value will be kept.
     """
 
     sigEditingFinished = qt.Signal()
+    """emit when edition is finished"""
 
     def __init__(self, parent=None, hide_lockers=True):
         super().__init__(parent)
@@ -227,70 +228,40 @@ class NXtomoEditor(qt.QWidget):
         self._yFlippedCB.toggled.connect(self._editingFinished)
         self._yFlippedLB.toggled.connect(self._editingFinished)
 
-    def _editingFinished(self, *args, **kwargs):
-        self.sigEditingFinished.emit()
-
-    def hasLockField(self) -> bool:
-        """return True if the widget has at least one lock field"""
-        return True in [locker.isLocked() for locker in self._lockerPBs]
-
-    def hideLockers(self, hide: bool):
-        for locker in self._lockerPBs:
-            locker.setVisible(not hide)
-
-    def getEditableWidgets(self):
-        return self._editableWidgets
-
-    def setScan(self, scan):
-        if scan is None:
-            self._scan = scan
-        elif not isinstance(scan, NXtomoScan):
-            raise TypeError(
-                f"{scan} is expected to be an instance of {NXtomoScan}. Not {type(scan)}"
-            )
-        else:
-            self._scan = weakref.ref(scan)
-        self._scanInfoQLE.setScan(scan)
-        # scan will only be read and not kept
-        self.update_tree()
-
-    def getScan(self):
-        if self._scan is None or self._scan() is None:
-            return None
-        else:
-            return self._scan()
-
-    def update_tree(self):
+    def update_tree(self) -> None:
         if self.getScan() is not None:
-            for fct in (
-                self._updateInstrument,
-                self._updateSample,
-            ):
-                try:
-                    fct()
-                except Exception as e:
-                    _logger.info(e)
+            self._updateInstrument()
+            self._updateSample()
             self._tree.resizeColumnToContents(0)
 
-    def _updateInstrument(self):
+    def _updateInstrument(self) -> None:
         scan = self.getScan()
         if scan is None:
             return
         else:
-            self._updateEnergy(scan=scan)
-            self._updatePixelSize(scan=scan)
-            self._updateFlipped(scan=scan)
-            self._updateFieldOfView(scan=scan)
-            self._updateDistance(scan=scan)
+            for name, fct in {
+                "energy": self._updateEnergy,
+                "pixel size": self._updatePixelSize,
+                "frame flips": self._updateFlipped,
+                "field of view": self._updateFieldOfView,
+                "sample-detector distance": self._updateDistance,
+            }.items():
+                try:
+                    fct(scan=scan)
+                except Exception as e:
+                    _logger.error(f"Failed to update {name}. Error is {e}")
 
-    def _updateSample(self):
+    def _updateSample(self) -> None:
         scan = self.getScan()
         if scan is None:
             return
         else:
-            self._updateTranslations(scan=scan)
+            try:
+                self._updateTranslations(scan=scan)
+            except Exception as e:
+                _logger.error(f"Fail to update translations. Error is {e}")
 
-    def _updateTranslations(self, scan: NXtomoScan):
+    def _updateTranslations(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
 
         # note: for now and in order to allow edition we expect to have at most a unique value. Will fail for helicoidal
@@ -313,32 +284,14 @@ class NXtomoEditor(qt.QWidget):
         self._xTranslationQLE.setValue(x_translation)
         self._zTranslationQLE.setValue(z_translation)
 
-    def _updateFieldOfView(self, scan):
+    def _updateFieldOfView(self, scan: NXtomoScan) -> None:
         if not self._fieldOfViewLB.isLocked():
             # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
             idx = self._fieldOfViewCB.findText(FOV.from_value(scan.field_of_view).value)
             if idx > 0:
                 self._fieldOfViewCB.setCurrentIndex(idx)
 
-    @staticmethod
-    @cache(maxsize=None)
-    def _get_UD_flip_matrix():
-        return UDDetTransformation().as_matrix()
-
-    @staticmethod
-    @cache(maxsize=None)
-    def _get_LR_flip_matrix():
-        return LRDetTransformation().as_matrix()
-
-    @staticmethod
-    @cache(maxsize=None)
-    def _get_UD_AND_LR_flip_matrix():
-        return numpy.matmul(
-            NXtomoEditor._get_UD_flip_matrix(),
-            NXtomoEditor._get_LR_flip_matrix(),
-        )
-
-    def _updateFlipped(self, scan):
+    def _updateFlipped(self, scan: NXtomoScan) -> None:
         transformations = list(scan.get_detector_transformations(tuple()))
         transformation_matrix_det_space = build_matrix(transformations)
         if transformation_matrix_det_space is None or numpy.allclose(
@@ -347,17 +300,17 @@ class NXtomoEditor(qt.QWidget):
             flip_ud = False
             flip_lr = False
         elif numpy.array_equal(
-            transformation_matrix_det_space, NXtomoEditor._get_UD_flip_matrix()
+            transformation_matrix_det_space, NXtomoEditorTask.Y_FLIP_MATRIX
         ):
             flip_ud = True
             flip_lr = False
         elif numpy.allclose(
-            transformation_matrix_det_space, NXtomoEditor._get_LR_flip_matrix()
+            transformation_matrix_det_space, NXtomoEditorTask.Z_FLIP_MATRIX
         ):
             flip_ud = False
             flip_lr = True
         elif numpy.allclose(
-            transformation_matrix_det_space, NXtomoEditor._get_UD_AND_LR_flip_matrix()
+            transformation_matrix_det_space, NXtomoEditorTask.Y_AND_Z_flip_MATRIX
         ):
             flip_ud = True
             flip_lr = True
@@ -372,19 +325,19 @@ class NXtomoEditor(qt.QWidget):
         if (not self._yFlippedLB.isLocked()) and flip_ud is not None:
             self._yFlippedCB.setChecked(flip_ud)
 
-    def _updateDistance(self, scan):
+    def _updateDistance(self, scan: NXtomoScan) -> None:
         if not self._distanceLB.isLocked():
             # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
             self._distanceMetricEntry.setValue(scan.distance)
 
-    def _updateEnergy(self, scan):
+    def _updateEnergy(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
         if not self._energyLockerLB.isLocked():
             # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
             energy = scan.energy
             self._energyEntry.setValue(energy)
 
-    def _updatePixelSize(self, scan):
+    def _updatePixelSize(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
         if not self._xPixelSizeLB.isLocked():
             x_pixel_size = scan.x_pixel_size
@@ -393,6 +346,39 @@ class NXtomoEditor(qt.QWidget):
             y_pixel_size = scan.y_pixel_size
             self._yPixelSizeMetricEntry.setValue(y_pixel_size)
 
+    def _editingFinished(self, *args, **kwargs):
+        self.sigEditingFinished.emit()
+
+    def hasLockField(self) -> bool:
+        """return True if the widget has at least one lock field"""
+        return True in [locker.isLocked() for locker in self._lockerPBs]
+
+    def hideLockers(self, hide: bool) -> None:
+        for locker in self._lockerPBs:
+            locker.setVisible(not hide)
+
+    def getEditableWidgets(self) -> tuple[qt.QWidget]:
+        return tuple(self._editableWidgets)
+
+    def setScan(self, scan: NXtomoScan | None) -> None:
+        if scan is None:
+            self._scan = scan
+        elif not isinstance(scan, NXtomoScan):
+            raise TypeError(
+                f"{scan} is expected to be an instance of {NXtomoScan}. Not {type(scan)}"
+            )
+        else:
+            self._scan = weakref.ref(scan)
+        self._scanInfoQLE.setScan(scan)
+        # scan will only be read and not kept
+        self.update_tree()
+
+    def getScan(self) -> NXtomoScan | None:
+        if self._scan is None or self._scan() is None:
+            return None
+        else:
+            return self._scan()
+
     def getConfiguration(self) -> dict:
         """
         Return a dict with field full name as key
@@ -401,37 +387,39 @@ class NXtomoEditor(qt.QWidget):
         limitation: for now sample position are not handled because this is a 'corner case' for now
         """
         return {
-            "instrument.beam.energy": (
+            NXtomoEditorKeys.ENERGY: (
                 self._energyEntry.getValue(),
                 self._energyLockerLB.isLocked(),
             ),
-            "instrument.detector.x_pixel_size": (
+            NXtomoEditorKeys.X_PIXEL_SIZE: (
                 self._xPixelSizeMetricEntry.getValue(),
                 self._xPixelSizeLB.isLocked(),
             ),
-            "instrument.detector.y_pixel_size": (
+            NXtomoEditorKeys.Y_PIXEL_SIZE: (
                 self._yPixelSizeMetricEntry.getValue(),
                 self._yPixelSizeLB.isLocked(),
             ),
-            "instrument.detector.distance": (
+            NXtomoEditorKeys.SAMPLE_DETECTOR_DISTANCE: (
                 self._distanceMetricEntry.getValue(),
                 self._distanceLB.isLocked(),
             ),
-            "instrument.detector.field_of_view": (
+            NXtomoEditorKeys.FIELD_OF_VIEW: (
                 self._fieldOfViewCB.currentText(),
                 self._fieldOfViewLB.isChecked(),
             ),
-            "instrument.detector.x_flipped": (
+            NXtomoEditorKeys.X_FLIPPED: (
                 self._xFlippedCB.isChecked(),
                 self._xFlippedLB.isChecked(),
             ),
-            "instrument.detector.y_flipped": (
+            NXtomoEditorKeys.Y_FLIPPED: (
                 self._yFlippedCB.isChecked(),
                 self._yFlippedLB.isChecked(),
             ),
+            NXtomoEditorKeys.X_TRANSLATION: (self._xTranslationQLE.getValue(),),
+            NXtomoEditorKeys.Z_TRANSLATION: (self._zTranslationQLE.getValue(),),
         }
 
-    def setConfiguration(self, config: dict):
+    def setConfiguration(self, config: dict) -> None:
         energy = config.get("instrument.beam.energy", None)
         if energy is not None:
             energy, energy_locked = energy
@@ -476,201 +464,27 @@ class NXtomoEditor(qt.QWidget):
             self._yFlippedCB.setChecked(y_flipped)
             self._yFlippedLB.setLock(y_flipped_locked)
 
-    def clear(self):
-        self._tree.clear()
-
-    def overwriteNXtomo(self):
-        """overwrite data on disk"""
-        scan = self.getScan()
-        if scan is None:
-            _logger.warning("no scan found to be saved")
-            return
-        nexus_paths = get_nexus_paths(scan.nexus_version)
-        assert isinstance(scan, NXtomoScan)
-        with HDF5File(scan.master_file, mode="a") as h5f:
-            entry = h5f[scan.entry]
-            # overwrite energy
-            energy = self._energyEntry.getValue()
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.ENERGY_PATH,
-                value=energy,
-                name="energy",
-                expected_type=float,
-                units="kev",
-            )
-            # overwrite x pixel size
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.X_PIXEL_SIZE_PATH,
-                value=self._xPixelSizeMetricEntry.getValue(),
-                name="x pixel size",
-                expected_type=float,
-                units="m",
-            )
-            # overwrite y pixel size
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.Y_PIXEL_SIZE_PATH,
-                value=self._yPixelSizeMetricEntry.getValue(),
-                name="y pixel size",
-                expected_type=float,
-                units="m",
-            )
-            n_frames = len(scan.image_key_control)
-
-            # overwrite x translation
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.X_TRANS_PATH,
-                value=self._xTranslationQLE.getValue(),
-                name="x translation",
-                expected_type=float,
-                n_value=n_frames,
-                units="m",
-            )
-            # overwrite z translation
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.Z_TRANS_PATH,
-                value=self._zTranslationQLE.getValue(),
-                name="z translation",
-                expected_type=float,
-                n_value=n_frames,
-                units="m",
-            )
-            # overwrite sample detector distance
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.DISTANCE_PATH,
-                value=self._distanceMetricEntry.getValue(),
-                name="z translation",
-                expected_type=float,
-                units="m",
-            )
-            # overwrite FOV
-            self.__write_to_file(
-                entry=entry,
-                path=nexus_paths.FOV_PATH,
-                value=self._fieldOfViewCB.currentText(),
-                name="field of view",
-                expected_type=str,
-            )
-
-            # solve NXtranformations
-            nx_transformations = NXtransformations()
-            if self._xFlippedCB.isChecked():
-                nx_transformations.add_transformation(LRDetTransformation())
-            if self._yFlippedCB.isChecked():
-                nx_transformations.add_transformation(UDDetTransformation())
-
-            nx_dict = nx_transformations.to_nx_dict(
-                nexus_path_version=scan.nexus_version,
-                data_path="/".join(
-                    (
-                        nexus_paths.INSTRUMENT_PATH,
-                        nexus_paths.nx_instrument_paths.DETECTOR_PATH,
-                    )
-                ),
-                solve_empty_dependency=True,
-            )
-            if nexus_paths.nx_detector_paths.NX_TRANSFORMATIONS is not None:
-                # old NXtomo are not handling NX_TRANSFORMATIONS
-                detector_transformation_path = "/".join(
-                    (
-                        nexus_paths.INSTRUMENT_PATH,
-                        nexus_paths.nx_instrument_paths.DETECTOR_PATH,
-                        nexus_paths.nx_detector_paths.NX_TRANSFORMATIONS,
-                    ),
-                )
-                if detector_transformation_path in entry:
-                    del entry[detector_transformation_path]
-
-                detector_transformation_path = "/".join(
-                    (scan.entry, detector_transformation_path)
-                )
-            else:
-                _logger.debug(
-                    "Old version of NXtomo found. No information about transformation will be saved"
-                )
-                detector_transformation_path = None
-
-        if detector_transformation_path is not None:
-            dicttonx(
-                nx_dict,
-                h5file=scan.master_file,
-                h5path=detector_transformation_path,
-                update_mode="replace",
-                mode="a",
-            )
-
-        # clear caches to make sure all modifications will be considered
-        scan.clear_caches()
-        scan.clear_frames_caches()
-
-    @staticmethod
-    def _newValueIsExistingValue(dataset: h5py.Dataset, new_value, units):
+    def getConfigurationForTask(self) -> dict:
         """
-        return true if the given value is same as the one stored
+        default configuration is stored as field: (field_value, filed_is_locked) when the task expects field_key: field_value
+        Because we need to be able to reload settings of the LockButton.
+        But the task doesn't care about it. She only want to know which field must be edited. So we need to filter the dict value.
         """
-        current_value = h5py_read_dataset(dataset)
-        attrs = dataset.attrs
-        current_unit = attrs.get("units", attrs.get("unit", None))
-        if units != current_unit:
-            # if the unit is not the same, eithen if the value is the same we will overwrite it
-            return False
-        else:
-            if isinstance(new_value, numpy.ndarray) and isinstance(
-                current_value, numpy.ndarray
-            ):
-                return numpy.array_equal(new_value, current_value)
-            elif numpy.isscalar(current_value) and numpy.isscalar(new_value):
-                return current_value == new_value
-            else:
-                return False
-
-    @staticmethod
-    def __write_to_file(
-        entry: h5py.Group, path: str, value, name, expected_type, n_value=1, units=None
-    ):
-        if path is None:
-            # if the path does not exists (no handled by this version of nexus for example)
-            return
+        return {key: value[0] for key, value in self.getConfiguration().items()}
 
-        # try to cast the value
-        if isinstance(value, str):
-            value = value.replace(" ", "")
-            if value.lower() == "none" or "..." in value:
-                # if value is not defined or is an array not overwrite by the user (case of the ... )
-                return
-        elif value is None:
-            pass
-        else:
-            try:
-                value = expected_type(value)
-            except (ValueError, TypeError) as e:
-                _logger.error(f"Fail to overwrite {name} of {entry.name}. Error is {e}")
-                return
-
-        if path in entry:
-            if NXtomoEditor._newValueIsExistingValue(
-                dataset=entry[path], new_value=value, units=units
-            ):
-                # if no need to overwrite
-                return
-            else:
-                del entry[path]
-        if value is None:
-            return
-        elif n_value == 1:
-            entry[path] = value
-        else:
-            entry[path] = numpy.array([value] * n_value)
-        if units is not None:
-            entry[path].attrs["units"] = units
+    def clear(self) -> None:
+        self._tree.clear()
 
 
 class _TranslationMetricEntry(MetricEntry):
+    """
+    Widget to define a translation along one axis.
+
+    The behavior is limited at the moment.
+    * either the array contains a unique value on the array and a float is displayed
+    * either the array contains several unique values and then '...' will be displayed. Users cannot provide an array in this case.
+    """
+
     LOADED_ARRAY = "loaded array"
 
     class TranslationValidator(qt.QDoubleValidator):
@@ -688,11 +502,10 @@ class _TranslationMetricEntry(MetricEntry):
         super().__init__(name, default_unit=default_unit, parent=parent)
         self._qlePixelSize.setValidator(self.TranslationValidator(self))
 
-    def getValue(self):
+    def getValue(self) -> float:
         """
 
         :return: the value in meter
-        :rtype: float
         """
         if "..." in self._qlePixelSize.text():
             # in this case this is the representation of an array, we don;t wan't to overwrite it
@@ -715,7 +528,7 @@ class EnergyEntry(qt.QLineEdit):
             a0 = str(a0)
         super().setText(a0)
 
-    def getValue(self) -> Optional[float]:
+    def getValue(self) -> float | None:
         txt = self.text().replace(" ", "")
         if txt in ("unknown", ""):
             return None

tomwer/gui/edit/nxtomowarmer.py

@@ -1,4 +1,5 @@
-from typing import Optional
+from __future__ import annotations
+
 import h5py
 from silx.gui import qt
 from silx.io.utils import open as open_hdf5
@@ -41,7 +42,7 @@ class NXtomoProxyWarmer(qt.QWidget):
         # set up
         self.setScan(None)
 
-    def setScan(self, scan: Optional[NXtomoScan]):
+    def setScan(self, scan: NXtomoScan | None):
         if scan is None:
             self._activateWarning(False)
         elif isinstance(scan, NXtomoScan):

tomwer/gui/edit/{test → tests}/test_dkrf_patch.py

@@ -1,31 +1,5 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 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__ = "28/10/2020"
+from __future__ import annotations
 
 
 import shutil
@@ -167,8 +141,8 @@ class TestDarkRefPatchWidget(TestCaseQt):
             file_path=self._scanWithDarkAndRef.master_file,
             data_path=self._scanWithDarkAndRef.entry,
         )
-        self._widget.setStartDarkUrl(url, serie_index=0)
-        self._widget.setStartFlatUrl(url, serie_index=1)
+        self._widget.setStartDarkUrl(url, series_index=0)
+        self._widget.setStartFlatUrl(url, series_index=1)
         self.assertTrue(self._widget.getStartDarkUrl() is not None)
         self.assertTrue(self._widget.getStartDarkUrl().is_valid())
         self.assertTrue(self._widget.getStartFlatUrl() is not None)

tomwer/gui/edit/{test → tests}/test_image_key_editor.py

@@ -1,31 +1,5 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 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__ = "28/10/2020"
+from __future__ import annotations
 
 
 import tempfile