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

tomwer/gui/stitching/tests/utils.py

@@ -0,0 +1,92 @@
+import os
+
+import numpy
+from nxtomo.application.nxtomo import NXtomo
+from scipy.ndimage import shift as shift_scipy
+from silx.image.phantomgenerator import PhantomGenerator
+from nxtomo.nxobject.nxdetector import ImageKey
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from nxtomo.utils.transformation import DetYFlipTransformation, DetZFlipTransformation
+
+
+def create_scans_z_series(
+    output_dir,
+    z_positions_m,
+    x_positions_m=None,
+    pixel_size=10e-6,
+    n_proj=20,
+    raw_frame_width=100,
+    final_frame_width=100,
+    shifts=None,
+    z_rois=None,
+    flip_lr: bool = False,
+    flip_ud: bool = False,
+):
+    """
+    :param Optional tuple: shift to be applied on the 2D frame
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    frame = (
+        PhantomGenerator.get2DPhantomSheppLogan(n=raw_frame_width).astype(numpy.float32)
+        * 256.0
+    )
+    if x_positions_m is None:
+        x_positions_m = [None] * len(z_positions_m)
+    if shifts is None:
+        shifts = [None] * len(z_positions_m)
+    if z_rois is None:
+        z_rois = [None] * len(z_positions_m)
+    scans = []
+    for i_frame, (z_pos, x_pos, z_roi, shift) in enumerate(
+        zip(z_positions_m, x_positions_m, z_rois, shifts)
+    ):
+        nx_tomo = NXtomo()
+        if z_pos is not None:
+            nx_tomo.sample.z_translation = [z_pos] * n_proj
+        if x_pos is not None:
+            nx_tomo.sample.x_translation = [x_pos] * n_proj
+        nx_tomo.sample.rotation_angle = numpy.linspace(
+            0, 180, num=n_proj, endpoint=False
+        )
+        nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
+        if pixel_size is not None:
+            if isinstance(pixel_size, (tuple, list)):
+                y_pix_size, x_pix_size = pixel_size
+            else:
+                y_pix_size, x_pix_size = pixel_size, pixel_size
+            nx_tomo.instrument.detector.x_pixel_size = x_pix_size
+            nx_tomo.instrument.detector.y_pixel_size = y_pix_size
+        nx_tomo.instrument.detector.distance = 2.3
+        nx_tomo.energy = 19.2
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            DetYFlipTransformation(flip=flip_ud)
+        )
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            DetZFlipTransformation(flip=flip_lr)
+        )
+
+        if shift is not None:
+            sub_frame = shift_scipy(
+                input=frame.copy(), shift=shift, order=1, mode="constant"
+            )[:final_frame_width]
+        else:
+            sub_frame = frame
+        if z_roi is not None:
+            roi_start, roi_end = z_roi
+            sub_frame = sub_frame[roi_start:roi_end]
+        else:
+            sub_frame = sub_frame
+        if flip_lr:
+            sub_frame = numpy.fliplr(sub_frame)
+        if flip_ud:
+            sub_frame = numpy.flipud(sub_frame)
+        nx_tomo.instrument.detector.data = numpy.asarray([sub_frame] * n_proj)
+
+        file_path = os.path.join(output_dir, f"nxtomo_{i_frame}.nx")
+        entry = f"entry000{i_frame}"
+        nx_tomo.save(file_path=file_path, data_path=entry)
+        scans.append(NXtomoScan(scan=file_path, entry=entry))
+
+    return scans

tomwer/gui/stitching/utils.py

@@ -0,0 +1,14 @@
+def concatenate_dict(dict_1, dict_2) -> dict:
+    """update dict which has dict as values. And we want concatenate those values to"""
+    res = dict_1.copy()
+    for key in dict_2:
+        if key in dict_1:
+            if key in [f"axis_{axis}_params" for axis in (0, 1, 2)]:
+                res[key] = ";".join((dict_1[key], dict_2[key]))
+            elif isinstance(dict_1[key], dict):
+                res[key] = concatenate_dict(dict_1=dict_1[key], dict_2=dict_2[key])
+            else:
+                res[key].update(dict_2[key])
+        else:
+            res[key] = dict_2[key]
+    return res

tomwer/gui/stitching/z_stitching/fineestimation.py

@@ -1,21 +1,15 @@
 """widgets to perform a z-sttiching in pre processing (from projections) or post processing (from reconstructed volumes)"""
 
-__author__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "20/01/2023"
+from __future__ import annotations
+
 
 import logging
-from typing import Union
 
 from nabu.stitching import config as _nabu_stitching_config
 from nabu.stitching.config import StitchingType
 from nabu.stitching.overlap import OverlapStitchingStrategy
 from nabu.stitching.utils import ShiftAlgorithm as _NabuShiftAlgorithm
 from silx.gui import qt
-from tomoscan.serie import Serie
-
-from tomwer.core.tomwer_object import TomwerObject
-from tomwer.gui.stitching.stitching_preview import PreviewStitchingPlot
 
 _logger = logging.getLogger(__name__)
 
@@ -79,7 +73,7 @@ class Axis_N_Params(qt.QGroupBox):
 
 class AutoRefineWidget(qt.QWidget):
     """
-    widget grouping information not specific to objects (output file, stithcing strategy...)
+    widget grouping information not specific to objects (output file, stitching strategy...)
     """
 
     def __init__(self, parent=None):
@@ -145,7 +139,7 @@ class AutoRefineWidget(qt.QWidget):
         self._preProcGroup.setVisible(mode is StitchingType.Z_PREPROC)
         self._postProcGroup.setVisible(mode is StitchingType.Z_POSTPROC)
 
-    def getSliceForPreview(self) -> Union[int, str]:
+    def getSliceForPreview(self) -> int | str:
         slice = self._sliceForPreview.text()
         try:
             return int(slice)
@@ -197,6 +191,7 @@ class _SliceGetter(qt.QLineEdit):
 
 class RefineEstimationCtrlWidget(qt.QWidget):
     sigSlicePreviewChanged = qt.Signal(str)
+    """emit when the slice preview has changed"""
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
@@ -222,26 +217,3 @@ class RefineEstimationCtrlWidget(qt.QWidget):
 
     def setSliceForPreview(self, slice: str):
         self._previewedSliceQLE.setText(str(slice))
-
-
-class RefineEstimationWidget(qt.QMainWindow):
-    def __init__(self, parent=None) -> None:
-        super().__init__(parent)
-        # central window
-        self._preview = PreviewStitchingPlot(parent=self)
-        self.setCentralWidget(self._preview)
-        # controls
-        self._controlWidget = RefineEstimationCtrlWidget(parent=self)
-        self._controlDockWidget = qt.QDockWidget(self)
-        self._controlDockWidget.setWidget(self._controlWidget)
-        self._controlDockWidget.setFeatures(qt.QDockWidget.DockWidgetMovable)
-        self.addDockWidget(qt.Qt.RightDockWidgetArea, self._controlDockWidget)
-
-    def addTomoObj(self, tomo_obj: TomwerObject):
-        pass
-
-    def setSerie(self, serie: Serie):
-        pass
-
-    def setStitchingType(self, stitching_type: StitchingType):
-        pass

tomwer/gui/stitching/z_stitching/tests/test_fine_estimation.py

@@ -0,0 +1,35 @@
+from nabu.stitching.utils import ShiftAlgorithm as _NabuShiftAlgorithm
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.stitching.z_stitching.fineestimation import Axis_N_Params
+
+
+class TestAxis_N_Params(TestCaseQt):
+    """
+    Test definition of an axis shift research parameters
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._widget = Axis_N_Params("axis n", None)
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+
+    def test(self):
+        self._widget.show()
+        assert self._widget.getCurrentMethod() == _NabuShiftAlgorithm.NONE
+        opts1 = self._widget.getOptsLine()
+        assert opts1 == "img_reg_method=None"
+        self._widget.setCurrentMethod(_NabuShiftAlgorithm.NABU_FFT)
+        opts2 = self._widget.getOptsLine()
+        assert opts2 == "img_reg_method=nabu-fft"
+        self._widget.setOptsLine(opts1)
+        assert self._widget.getOptsLine() == opts1
+        self._widget.setOptsLine(opts2)
+        assert self._widget.getOptsLine() == opts2

tomwer/gui/stitching/z_stitching/tests/test_raw_estimation.py

@@ -0,0 +1,215 @@
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.stitching.metadataholder import StitchingMetadata
+from tomwer.gui.stitching.metadataholder import QStitchingMetadata
+from tomwer.gui.stitching.tests.utils import create_scans_z_series
+from tomwer.gui.stitching.config.tomoobjdetails import TomoObjectPositionInfos
+from tomwer.gui.stitching.axisorderedlist import AxisOrderedTomoObjsModel
+
+
+class TestTomoObjectPositionInfos(TestCaseQt):
+    """
+    Test edition of the tomo object position information
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self._y_pixel_size = 0.002
+        self._x_pixel_size = 0.001
+        self.scans = create_scans_z_series(
+            self._tmp_path,
+            z_positions_m=(0.200, 0.205, 0.210),
+            x_positions_m=(0.0, 0.0, None),
+            pixel_size=(self._y_pixel_size, self._x_pixel_size),
+            raw_frame_width=100,
+        )
+        self.scan_0_metadata = QStitchingMetadata(tomo_obj=self.scans[0])
+        assert self.scan_0_metadata.get_raw_position_m(axis=0) == 0.20
+        assert self.scan_0_metadata.get_raw_position_m(axis=2) == 0.0
+        self.scan_2_metadata = QStitchingMetadata(tomo_obj=self.scans[2])
+        assert self.scan_2_metadata.get_raw_position_m(axis=0) == 0.21
+        self._widget = TomoObjectPositionInfos()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    def testEdition(self):
+        # test QStitchingMetadata are correctly read
+        self._widget.show()
+        self._widget.setStitchingMetadata(self.scan_0_metadata)
+        self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(0.20 / 0.002)
+        assert self._widget._axis_2_pos.get_final_px_position() == 0
+        self._widget.setStitchingMetadata(self.scan_2_metadata)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(0.21 / 0.002)
+        assert self._widget._axis_2_pos.get_final_px_position() is None
+        # test editing some parameters from the GUI. Make sure GUI is updated as the underlying metadata object
+        self._widget._axis_0_pos._overrideMetricPositionCB.setChecked(True)
+        self._widget._axis_0_pos.setRawMetricPosition(
+            position_m=0.4, displayed_unit="nm"
+        )
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(
+            0.4 * 10e-6 / 0.002
+        )
+        self._widget._axis_0_pos._overridePixelPositionCB.setChecked(True)
+        self._widget._axis_0_pos.setOverrridePxPosition(position_px=120)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(120)
+        assert self.scan_2_metadata.get_abs_position_px(axis=0) == int(120)
+
+
+class TestAxisOrderedTomoObjsModel(TestCaseQt):
+    """
+    test the behavior of the z ordered model used for stitching
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.scans_with_pos_and_pixel_size = create_scans_z_series(
+            os.path.join(self._tmp_path, "case1"),
+            z_positions_m=(0.200, 0.205, 0.210),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+        self.scans_with_pixel_size = create_scans_z_series(
+            os.path.join(self._tmp_path, "case2"),
+            z_positions_m=(None, None, None),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+        self.scans_without_metadata = create_scans_z_series(
+            os.path.join(self._tmp_path, "case3"),
+            z_positions_m=(None, None, None),
+            pixel_size=None,
+            raw_frame_width=100,
+        )
+        self._widget = qt.QTableView()
+        self._widget.setModel(AxisOrderedTomoObjsModel(parent=self._widget, axis=0))
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    def testWithMetadata(self):
+        """
+        make sure z ordering works in the best case scenario
+        """
+        first_expected_scan = (
+            self.scans_with_pos_and_pixel_size[2].get_identifier().short_description()
+        )
+        # try giving it ordered
+        for scan in self.scans_with_pos_and_pixel_size[::-1]:
+            self._widget.model().addTomoObj(scan)
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == first_expected_scan
+        )
+        self._widget.model().clearTomoObjs()
+        # try giving it ordered (but inverted)
+        for scan in self.scans_with_pos_and_pixel_size:
+            self._widget.model().addTomoObj(scan)
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == first_expected_scan
+        )
+
+    def testWithPixelSizeOnly(self):
+        """
+        make sure z ordering works when we are only aware about pixel size
+        """
+        for scan in self.scans_with_pixel_size[::-1]:
+            self._widget.model().addTomoObj(scan)
+
+        # try adding some metadata to object
+        scans = self._widget.model()._objs
+        scans = self._widget.model()._objs
+        scans[0].stitching_metadata = StitchingMetadata(tomo_obj=scans[0])
+        scans[1].stitching_metadata = QStitchingMetadata(tomo_obj=scans[1])
+
+        scans[0].stitching_metadata._pos_as_m = (0.1, 1, 2)
+        scans[1].stitching_metadata._pos_as_m = (-0.03, 1, 2)
+        scans[2].stitching_metadata._pos_as_m = (0.23, 1, 2)
+
+        self._widget.model().reorder_objs()
+        self._widget.model().layoutChanged.emit()
+
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == scans[2].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(1, 1), qt.Qt.DisplayRole
+            )
+            == scans[0].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(2, 1), qt.Qt.DisplayRole
+            )
+            == scans[1].get_identifier().short_description()
+        )
+
+    def testWithoutMetadata(self):
+        """
+        make sure tomo obj are still displayed even if there is no metadata at all
+        """
+        for scan in self.scans_without_metadata[::-1]:
+            self._widget.model().addTomoObj(scan)
+        # try adding some metadata to object
+        scans = self._widget.model()._objs
+        scans[0].stitching_metadata = StitchingMetadata(tomo_obj=scans[0])
+        scans[1].stitching_metadata = QStitchingMetadata(tomo_obj=scans[1])
+
+        scans[0].stitching_metadata._pos_as_px = (12, None, 2)
+        scans[1].stitching_metadata._pos_as_px = (-12, None, None)
+        scans[2].stitching_metadata._pos_as_px = (9999, None, None)
+
+        self._widget.model().reorder_objs()
+        self._widget.model().layoutChanged.emit()
+
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == scans[2].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(1, 1), qt.Qt.DisplayRole
+            )
+            == scans[0].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(2, 1), qt.Qt.DisplayRole
+            )
+            == scans[1].get_identifier().short_description()
+        )

tomwer/gui/stitching/z_stitching/tests/test_stitching_window.py

@@ -0,0 +1,51 @@
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.stitching.tests.utils import create_scans_z_series
+from tomwer.gui.stitching.StitchingWindow import ZStitchingWindow
+
+
+class TestZStichingWindow(TestCaseQt):
+    """
+    Test high level z stitching definition
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.scans = create_scans_z_series(
+            os.path.join(self._tmp_path, "case1"),
+            z_positions_m=(0.200, 0.205, 0.210),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+
+        self._widget = ZStitchingWindow()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    @staticmethod
+    def checkNbReceivers(scan, nb_receivers):
+        return (
+            scan.stitching_metadata.receivers(scan.stitching_metadata.sigChanged)
+            == nb_receivers
+        )
+
+    def test(self):
+        self._widget.show()
+        # fill the widget with scans
+
+        scan_0, scan_1, scan_2 = self.scans
+        for scan in self.scans:
+            self._widget.addTomoObj(scan)
+            # note: add the sigChanged to the z ordered list 'update z' slot

tomwer/gui/tests/test_axis_gui.py

@@ -0,0 +1,43 @@
+import pytest
+import numpy
+
+from tomwer.gui.reconstruction.axis.AxisSettingsWidget import AxisSettingsTabWidget
+from tomwer.synctools.axis import QAxisRP
+from tomwer.tests.utils import skip_gui_test
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+def test_get_nabu_cor_opts(qtapp):  # noqa F811
+    axis_params = QAxisRP()
+    widget = AxisSettingsTabWidget(recons_params=axis_params)
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+    }
+    widget._optionsWidget._corOpts.setText("low_pass=2.0")
+    widget._optionsWidget._corOpts.editingFinished.emit()
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+    }
+    widget._optionsWidget._corOpts.setText("low_pass=2 ; high_pass=10")
+    widget._optionsWidget._corOpts.editingFinished.emit()
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "right",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+        "high_pass": 10.0,
+    }
+    widget._calculationWidget.setEstimatedCorValue("left")
+    assert axis_params.get_nabu_cor_options_as_dict() == {
+        "side": "left",
+        "radio_angles": (0.0, numpy.pi),
+        "slice_idx": "middle",
+        "low_pass": 2.0,
+        "high_pass": 10.0,
+    }

tomwer/gui/{test → tests}/test_qfolder_dialog.py

@@ -1,6 +1,6 @@
 import pytest
 
-from tomwer.gui.qfolderdialog import QDataDialog
+from tomwer.gui.dialog.QDataDialog import QDataDialog
 from tomwer.tests.conftest import qtapp  # noqa F401
 
 

tomwer/gui/utils/RangeWidget.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import sys
+from silx.gui import qt
+
+
+class RangeWidget(qt.QWidget):
+    """widget to select a range of float"""
+
+    sigChanged = qt.Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setLayout(qt.QHBoxLayout())
+
+        # start
+        self.layout().addWidget(qt.QLabel("from"))
+        self._startQLE = qt.QDoubleSpinBox(self)
+        self.layout().addWidget(self._startQLE)
+        self._startQLE.setRange(sys.float_info.min, sys.float_info.max)
+
+        # stop
+        self.layout().addWidget(qt.QLabel("to"))
+        self._stopQLE = qt.QDoubleSpinBox(self)
+        self.layout().addWidget(self._stopQLE)
+        self._stopQLE.setRange(sys.float_info.min, sys.float_info.max)
+
+        # connect signal / slot
+        self._startQLE.editingFinished.connect(self.sigChanged)
+        self._stopQLE.editingFinished.connect(self.sigChanged)
+
+    def getRange(self) -> tuple[float]:
+        return (
+            self._startQLE.value(),
+            self._stopQLE.value(),
+        )
+
+    def setRange(self, start: float, stop: float) -> None:
+        self._startQLE.setValue(float(start))
+        self._stopQLE.setValue(float(stop))
+
+    def setSuffix(self, suffix: str):
+        self._startQLE.setSuffix(suffix)
+        self._stopQLE.setSuffix(suffix)

tomwer/gui/utils/buttons.py

@@ -2,9 +2,10 @@
 Button of general usage.
 """
 
+from __future__ import annotations
+
 import numpy
 import logging
-from typing import Optional, Union
 from silx.gui import qt
 from silx.gui.plot.tools.roi import RegionOfInterestManager
 from silx.gui.plot.items.roi import LineROI
@@ -102,7 +103,7 @@ class TapeMeasureToolButton(PlotToolButton):
                 value, unit = MetricSystem.cast_metric_to_best_unit(distance_m)
                 self._updateText(f"{distance_px :.1f}px ({value:.2f}{unit})")
 
-        def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+        def setPixelSize(self, pixel_size_m: tuple | float | None):
             if isinstance(pixel_size_m, (tuple, list)):
                 assert (
                     len(pixel_size_m) == 2
@@ -128,7 +129,7 @@ class TapeMeasureToolButton(PlotToolButton):
     def setPlot(self, plot):
         return super().setPlot(plot)
 
-    def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+    def setPixelSize(self, pixel_size_m: tuple | float | None):
         self._pixel_sixel_m = pixel_size_m
 
     def _callback(self, toggled):

tomwer/gui/utils/completer.py

@@ -1,37 +1,6 @@
-# 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 defining dedicated completer"""
 
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "23/03/2022"
-
-
-from typing import Optional
+from __future__ import annotations
 
 from silx.gui import qt
 
@@ -103,7 +72,7 @@ class _TextCompleterWidget(qt.QWidget):
 
 class UrlCompleterDialog(qt.QDialog):
     def __init__(
-        self, urls: tuple, parent=None, current_url: Optional[str] = None
+        self, urls: tuple, parent=None, current_url: str | None = None
     ) -> None:
         super().__init__(parent)
         self._urls = urls