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

tomwer/gui/control/{serie/seriecreator.py → series/seriescreator.py}

@@ -1,57 +1,29 @@
-# 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__ = "12/01/2022"
-
+from __future__ import annotations
 
 import logging
 from contextlib import AbstractContextManager
-from typing import Iterable, Optional
+from typing import Iterable
 
 from silx.gui import qt
 from silx.gui.utils import blockSignals
 from silx.utils.enum import Enum as _Enum
-from tomoscan.serie import Serie
+from tomoscan.series import Series
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.gui.control.datalist import TomoObjList
-from tomwer.gui.qfolderdialog import QDataDialog
+from tomwer.gui.dialog.QDataDialog import QDataDialog
 from tomwer.gui.visualization.tomoobjoverview import TomoObjOverview
 
 _logger = logging.getLogger(__name__)
 
 
-class SerieWidgetDialog(qt.QDialog):
-    sigSerieSelected = qt.Signal(Serie)
+class SeriesWidgetDialog(qt.QDialog):
+    sigSeriesSelected = qt.Signal(Series)
     """
-    emit when a serie is selected / triggered by the user
+    emit when a series is selected / triggered by the user
     """
 
     def __init__(self, *args, **kwargs) -> None:
@@ -59,108 +31,110 @@ class SerieWidgetDialog(qt.QDialog):
 
         self.setLayout(qt.QVBoxLayout())
         # add list
-        self._widget = SerieWidget()
+        self._widget = SeriesWidget()
         self.layout().addWidget(self._widget)
         # add buttons
         self._buttons = qt.QDialogButtonBox(parent=self)
-        self._selectButton = qt.QPushButton("Select (active) serie", parent=self)
+        self._selectButton = qt.QPushButton("Select (active) series", parent=self)
         self._buttons.addButton(self._selectButton, qt.QDialogButtonBox.ActionRole)
         self.layout().addWidget(self._buttons)
 
         # connect signal / slot
-        self._selectButton.released.connect(self._serieSelected)
+        self._selectButton.released.connect(self._seriesSelected)
 
-    def getSelectedSerie(self) -> Optional[Serie]:
-        return self._widget.getSelectedSerie()
+    def getSelectedSeries(self) -> Series | None:
+        return self._widget.getSelectedSeries()
 
-    def _serieSelected(self, *args, **kwargs):
-        serie = self.getSelectedSerie()
-        if serie is not None:
-            self.sigSerieSelected.emit(serie)
+    def _seriesSelected(self, *args, **kwargs):
+        series = self.getSelectedSeries()
+        if series is not None:
+            self.sigSeriesSelected.emit(series)
 
     # expose API
     def add(self, tomo_obj):
         self._widget.add(tomo_obj=tomo_obj)
 
 
-class SerieWidget(qt.QTabWidget):
-    sigCurrentSerieChanged = qt.Signal()
-    """signal emit when the current serie changes"""
+class SeriesWidget(qt.QTabWidget):
+    sigCurrentSeriesChanged = qt.Signal()
+    """signal emit when the current series changes"""
 
     sigHistoryChanged = qt.Signal()
-    """signal emit when the history changed (a serie has been added or removed"""
+    """signal emit when the history changed (a series has been added or removed"""
 
-    sigSerieSend = qt.Signal(Serie)
-    """Signal emited when a serie has been send"""
+    sigSeriesSend = qt.Signal(Series)
+    """Signal emit when a series has been send"""
 
     _HISTORY_MODE = "history"
-    _DEFINITION_MODE = "serie definition"
+    _DEFINITION_MODE = "series definition"
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
-        self.setWindowTitle("serie of scans")
-        self._serieDefinitionWidget = SerieDefinition(parent=self)
-        self.addTab(self._serieDefinitionWidget, self._DEFINITION_MODE)
-        self._historyWidget = SerieHistoryDialog(parent=self)
+        self.setWindowTitle("series of scans")
+        self._seriesDefinitionWidget = SeriesDefinition(parent=self)
+        self.addTab(self._seriesDefinitionWidget, self._DEFINITION_MODE)
+        self._historyWidget = SeriesHistoryDialog(parent=self)
         self._historyWidget.setWindowFlags(qt.Qt.Widget)
         self.addTab(self._historyWidget, self._HISTORY_MODE)
 
-        # conenct signal / slot
-        self._historyWidget.sigEditSerie.connect(self._serieEditionRequested)
-        self._historyWidget.sigSerieSend.connect(self.sigSerieSend)
+        # connect signal / slot
+        self._historyWidget.sigEditSeries.connect(self._seriesEditionRequested)
+        self._historyWidget.sigSeriesSend.connect(self.sigSeriesSend)
         self._historyWidget.sigHistoryUpdated.connect(self._repeatHistoryUpdated)
-        self._serieDefinitionWidget.sigSerieChanged.connect(self._repeatSerieChanged)
-        self._serieDefinitionWidget.sigSerieSend.connect(self.sigSerieSend)
-        self._serieDefinitionWidget.sigSerieSend.connect(self._historyWidget.addSerie)
+        self._seriesDefinitionWidget.sigSeriesChanged.connect(self._repeatSeriesChanged)
+        self._seriesDefinitionWidget.sigSeriesSend.connect(self.sigSeriesSend)
+        self._seriesDefinitionWidget.sigSeriesSend.connect(
+            self._historyWidget.addSeries
+        )
 
     def getHistoryWidget(self):
         return self._historyWidget
 
     def getDefinitionWidget(self):
-        return self._serieDefinitionWidget
+        return self._seriesDefinitionWidget
 
-    def getSelectedSerie(self) -> Optional[Serie]:
-        return self._serieDefinitionWidget.getSelectedSerie()
+    def getSelectedSeries(self) -> Series | None:
+        return self._seriesDefinitionWidget.getSelectedSeries()
 
-    def setMode(self, mode: str, definition_mode: Optional[str] = None):
+    def setMode(self, mode: str, definition_mode: str | None = None):
         valid_modes = (self._HISTORY_MODE, self._DEFINITION_MODE)
         if mode == self._HISTORY_MODE:
             self.setCurrentWidget(self._historyWidget)
         elif mode == self._DEFINITION_MODE:
-            self.setCurrentWidget(self._serieDefinitionWidget)
-            self._serieDefinitionWidget.setMode(definition_mode)
+            self.setCurrentWidget(self._seriesDefinitionWidget)
+            self._seriesDefinitionWidget.setMode(definition_mode)
         else:
             raise ValueError(
                 f"mode {mode} is no recognized. Valid modes are {valid_modes}"
             )
 
-    def _serieEditionRequested(self, serie: Serie):
-        if not isinstance(serie, Serie):
-            raise TypeError(f"serie is expected to be a serie not {type(serie)}")
-        self.setMode("serie definition", "manual")
-        self.getDefinitionWidget().getManualDefinitionWidget().setSerie(serie)
+    def _seriesEditionRequested(self, series: Series):
+        if not isinstance(series, Series):
+            raise TypeError(f"series is expected to be a series not {type(series)}")
+        self.setMode("series definition", "manual")
+        self.getDefinitionWidget().getManualDefinitionWidget().setSeries(series)
 
-    def _repeatSerieChanged(self, *args, **kwargs):
-        self.sigCurrentSerieChanged.emit()
+    def _repeatSeriesChanged(self, *args, **kwargs):
+        self.sigCurrentSeriesChanged.emit()
 
     def _repeatHistoryUpdated(self, *args, **kwargs):
         self.sigHistoryChanged.emit()
 
     def add(self, tomo_obj):
-        return self._serieDefinitionWidget.addTomoObj(tomo_obj)
+        return self._seriesDefinitionWidget.addTomoObj(tomo_obj)
 
 
-class _SerieDefinitionMode(_Enum):
+class _SeriesDefinitionMode(_Enum):
     MANUAL = "manual"
     AUTO = "auto"
 
 
-class SerieDefinition(qt.QWidget):
-    sigSerieChanged = qt.Signal()
-    ### signal emit when a the serie defined manually changed
+class SeriesDefinition(qt.QWidget):
+    sigSeriesChanged = qt.Signal()
+    """signal emit when a the series defined manually changed"""
 
-    sigSerieSend = qt.Signal(Serie)
-    ### signal emit when a serie is send
+    sigSeriesSend = qt.Signal(Series)
+    """Signal emited when a series has been send"""
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
@@ -170,41 +144,43 @@ class SerieDefinition(qt.QWidget):
         self.layout().addWidget(self._modeLabel, 0, 0, 1, 1)
 
         self._modeCB = qt.QComboBox(self)
-        for mode in _SerieDefinitionMode.values():
+        for mode in _SeriesDefinitionMode.values():
             self._modeCB.addItem(mode)
         self.layout().addWidget(self._modeCB, 0, 1, 1, 1)
 
-        self._manualDefWidget = SerieManualFromTomoObj(parent=self)
+        self._manualDefWidget = SeriesManualFromTomoObj(parent=self)
         self.layout().addWidget(self._manualDefWidget, 1, 0, 1, 2)
         self._manualDefWidget.setWindowFlags(qt.Qt.Widget)
 
-        self._automaticDefWidget = SerieAutomaticDefinitionWidget(parent=self)
+        self._automaticDefWidget = SeriesAutomaticDefinitionWidget(parent=self)
         self.layout().addWidget(self._automaticDefWidget, 2, 0, 1, 2)
 
         # connect signal / slot
         self._modeCB.currentIndexChanged.connect(self._updateVisibility)
-        self._manualDefWidget._newSerieWidget.sigUpdated.connect(self.sigSerieChanged)
+        self._manualDefWidget._newSeriesWidget.sigUpdated.connect(self.sigSeriesChanged)
 
         # set up
         self._updateVisibility()
 
-    def getSelectedSerie(self) -> Optional[Serie]:
-        if self.getMode() == _SerieDefinitionMode.MANUAL:
-            return self._manualDefWidget.getSerie()
+    def getSelectedSeries(self) -> Series | None:
+        if self.getMode() == _SeriesDefinitionMode.MANUAL:
+            return self._manualDefWidget.getSeries()
         else:
             raise ValueError(f"mode {self.getMode()} is not handled yet")
 
     def getMode(self) -> str:
-        return _SerieDefinitionMode.from_value(self._modeCB.currentText())
+        return _SeriesDefinitionMode.from_value(self._modeCB.currentText())
 
     def setMode(self, mode: str):
-        mode = _SerieDefinitionMode.from_value(mode)
+        mode = _SeriesDefinitionMode.from_value(mode)
         idx = self._modeCB.findText(mode.value)
         self._modeCB.setCurrentIndex(idx)
 
     def _updateVisibility(self):
-        self._manualDefWidget.setVisible(self.getMode() == _SerieDefinitionMode.MANUAL)
-        self._automaticDefWidget.setVisible(self.getMode() == _SerieDefinitionMode.AUTO)
+        self._manualDefWidget.setVisible(self.getMode() == _SeriesDefinitionMode.MANUAL)
+        self._automaticDefWidget.setVisible(
+            self.getMode() == _SeriesDefinitionMode.AUTO
+        )
 
     def getManualDefinitionWidget(self):
         return self._manualDefWidget
@@ -212,24 +188,24 @@ class SerieDefinition(qt.QWidget):
     def getAutoDefinitionWidget(self):
         return self._automaticDefWidget
 
-    def createManualSerie(self):
-        self._manualDefWidget.createSerie()
+    def createManualSeries(self):
+        self._manualDefWidget.createSeries()
 
     def addTomoObj(self, tomo_obj: TomwerObject):
         self._manualDefWidget.addTomoObj(tomo_obj=tomo_obj)
 
-    def setSerieName(self, name: str):
-        self._manualDefWidget.setSerieName(name=name)
+    def setSeriesName(self, name: str):
+        self._manualDefWidget.setSeriesName(name=name)
 
 
-class _SerieDefinitionTree(qt.QWidget):
+class _SeriesDefinitionTree(qt.QWidget):
     """
-    Tree used to define manually serie of scan.
+    Tree used to define manually series of scan.
     Drag and drop of files is handled
     """
 
     sigUpdated = qt.Signal()
-    """Signal emit when the serie is updated"""
+    """Signal emit when the series is updated"""
 
     class SignalBlocker(AbstractContextManager):
         """Simple context manager to hide / show button dialogs"""
@@ -254,15 +230,15 @@ class _SerieDefinitionTree(qt.QWidget):
         self._tree = qt.QTreeWidget(self)
         self._tree.setSelectionMode(qt.QAbstractItemView.MultiSelection)
         self._tree.setColumnCount(2)
-        self._tree.setHeaderLabels(("serie", "scan ids"))
+        self._tree.setHeaderLabels(("series", "scan ids"))
         self._tree.setItemsExpandable(False)
         self.layout().addWidget(self._tree)
 
         # set up the tree with the serie name that will stay during the entire
         # life time of the tree
-        self._serieItem = qt.QTreeWidgetItem(self._tree)
-        self._serieItem.setFlags(self._serieItem.flags() | qt.Qt.ItemIsEditable)
-        self._serieItem.setExpanded(True)
+        self._seriesItem = qt.QTreeWidgetItem(self._tree)
+        self._seriesItem.setFlags(self._seriesItem.flags() | qt.Qt.ItemIsEditable)
+        self._seriesItem.setExpanded(True)
 
         self.setAcceptDrops(True)
 
@@ -270,22 +246,22 @@ class _SerieDefinitionTree(qt.QWidget):
         self._tree.itemChanged.connect(self._updated)
 
         # set up
-        self.setSerieName(name=serie_name)
+        self.setSeriesName(name=serie_name)
 
         # expose API
         self.itemChanged = self._tree.itemChanged
 
     @property
     def rootItem(self):
-        return self._serieItem
+        return self._seriesItem
 
-    def setSerieName(self, name: str):
+    def setSeriesName(self, name: str):
         with self.SignalBlocker(self):
-            self._serieItem.setText(0, name)
+            self._seriesItem.setText(0, name)
         self.sigUpdated.emit()
 
-    def getSerieName(self):
-        return self._serieItem.text(0)
+    def getSeriesName(self):
+        return self._seriesItem.text(0)
 
     def addTomoObj(self, tomo_obj: TomwerObject):
         if not isinstance(tomo_obj, TomwerObject):
@@ -324,16 +300,16 @@ class _SerieDefinitionTree(qt.QWidget):
     def n_tomo_objs(self):
         return len(self._tomo_objs)
 
-    def setSerie(self, serie: Serie) -> None:
-        if not isinstance(serie, Serie):
+    def setSeries(self, series: Series) -> None:
+        if not isinstance(series, Series):
             raise TypeError(
-                f"serie is expected to be an instance of {Serie} not {type(serie)}"
+                f"serie is expected to be an instance of {Series} not {type(series)}"
             )
 
         with self.SignalBlocker(self):
             self.clearTomoObjs()
-            self.setSerieName(serie.name)
-            for tomo_obj in serie:
+            self.setSeriesName(series.name)
+            for tomo_obj in series:
                 if isinstance(tomo_obj, str):
                     try:
                         tomo_obj = ScanFactory.create_tomo_object_from_identifier(
@@ -354,10 +330,10 @@ class _SerieDefinitionTree(qt.QWidget):
                 self.addTomoObj(tomo_obj)
         self.sigUpdated.emit()
 
-    def getSerie(self, use_identifiers=False) -> Serie:
+    def getSeries(self, use_identifiers=False) -> Series:
         scans = [scan for scan, _ in self._tomo_objs.values()]
-        return Serie(
-            name=self.getSerieName(),
+        return Series(
+            name=self.getSeriesName(),
             iterable=scans,
             use_identifiers=use_identifiers,
         )
@@ -378,7 +354,7 @@ class _SerieDefinitionTree(qt.QWidget):
             if scan_item is not None:
                 scan_item.setSelected(True)
 
-    def _getTomoObjItem(self, tomo_obj: TomwerObject) -> Optional[qt.QTreeWidgetItem]:
+    def _getTomoObjItem(self, tomo_obj: TomwerObject) -> qt.QTreeWidgetItem | None:
         if not isinstance(tomo_obj, TomwerObject):
             raise TypeError(
                 f"scan is expected to be an instance of {TomwerObject} not {type(tomo_obj)}"
@@ -404,7 +380,7 @@ class _SerieDefinitionTree(qt.QWidget):
     def clearSelection(self) -> None:
         self._tree.selectionModel().clearSelection()
 
-    def addScanFromNxFile(self, file_: str, entry: Optional[str] = None):
+    def addScanFromNxFile(self, file_: str, entry: str | None = None):
         try:
             if entry is None:
                 scans = ScanFactory.create_scan_objects(scan_path=file_)
@@ -452,18 +428,19 @@ class _SerieDefinitionTree(qt.QWidget):
             qt.QListWidget.dragMoveEvent(self, event)
 
 
-class SerieManualControlDialog(qt.QDialog):
+class SeriesManualControlDialog(qt.QDialog):
     """
-    Same as the :class:`SerieManualDefinitionDialog` but with control of the serie.
-    This include a `create serie` and a `create serie and clear button`
+    Same as the :class:`SeriesManualDefinitionDialog` but with control of the serie.
+    This include a `create series` and a `create series and clear button`
     """
 
-    sigSerieSend = qt.Signal(Serie)
+    sigSeriesSend = qt.Signal(Series)
+    """Signal emit when a series has been send"""
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
-        self._mainWidget = SerieManualDefinitionDialog(parent=self)
+        self._mainWidget = SeriesManualDefinitionDialog(parent=self)
         self._mainWidget.setWindowFlags(qt.Qt.Widget)
         self.layout().addWidget(self._mainWidget)
 
@@ -472,32 +449,32 @@ class SerieManualControlDialog(qt.QDialog):
         self._buttons.addButton(self._createButton, qt.QDialogButtonBox.ActionRole)
 
         # connect signal / slot
-        self._createButton.clicked.connect(self._sendSerie)
+        self._createButton.clicked.connect(self._sendSeries)
         self.layout().addWidget(self._buttons)
 
         # expose API
         self.sigUpdated = self._mainWidget.sigUpdated
 
-    def _sendSerie(self):
-        self.sigSerieSend.emit(self._mainWidget.getSerie())
+    def _sendSeries(self):
+        self.sigSeriesSend.emit(self._mainWidget.getSeries())
 
     @property
     def n_tomo_objs(self):
         return self._mainWidget.n_tomo_objs
 
-    def setSerieName(self, name: str):
-        self._mainWidget.setSerieName(name=name)
+    def setSeriesName(self, name: str):
+        self._mainWidget.setSeriesName(name=name)
 
-    def getSerieName(self) -> str:
-        return self._mainWidget.getSerieName()
+    def getSeriesName(self) -> str:
+        return self._mainWidget.getSeriesName()
 
-    def setSerie(self, serie: Serie) -> None:
-        self._mainWidget.setSerie(serie)
+    def setSeries(self, series: Series) -> None:
+        self._mainWidget.setSeries(series)
 
-    def getSerie(self, *args, **kwargs) -> Serie:
-        return self._mainWidget.getSerie(*args, **kwargs)
+    def getSeries(self, *args, **kwargs) -> Series:
+        return self._mainWidget.getSeries(*args, **kwargs)
 
-    def addScanFromNxFile(self, file_: str, entry: Optional[str] = None):
+    def addScanFromNxFile(self, file_: str, entry: str | None = None):
         return self._mainWidget.addScanFromNxFile(file_=file_, entry=entry)
 
     def removeSelectedScans(self) -> None:
@@ -515,14 +492,14 @@ class SerieManualControlDialog(qt.QDialog):
     def removeScan(self, scan: TomwerScanBase) -> None:
         self._mainWidget.removeTomoObj(scan=scan)
 
-    def clearSerie(self) -> None:
-        self._mainWidget.clearSerie()
+    def clearSeries(self) -> None:
+        self._mainWidget.clearSeries()
 
-    def createSerie(self):
-        self.sigSerieSend.emit(self.getSerie())
+    def createSeries(self):
+        self.sigSeriesSend.emit(self.getSeries())
 
 
-class SerieManualFromTomoObj(qt.QWidget):
+class SeriesManualFromTomoObj(qt.QWidget):
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
         style = qt.QApplication.style()
@@ -552,11 +529,11 @@ class SerieManualFromTomoObj(qt.QWidget):
         self._leftArrowButton.setFixedWidth(30)
         self.layout().addWidget(self._leftArrowButton, 2, 2, 1, 1)
 
-        # new serie
-        self._newSerieWidget = NewSerieWidget(self)
+        # new series
+        self._newSeriesWidget = NewSeriesWidget(self)
         self._newSerieWidgetScrollArea = qt.QScrollArea(self)
         self._newSerieWidgetScrollArea.setWidgetResizable(True)
-        self._newSerieWidgetScrollArea.setWidget(self._newSerieWidget)
+        self._newSerieWidgetScrollArea.setWidget(self._newSeriesWidget)
         self.layout().addWidget(self._newSerieWidgetScrollArea, 0, 3, 4, 2)
 
         # tomo obj details
@@ -574,18 +551,17 @@ class SerieManualFromTomoObj(qt.QWidget):
     def selectedTomoObjects(self) -> tuple:
         """
         :return: tuple of tomo object selected on the list
-        :rtype: tuple
         """
         items = self._tomoObjList.selectedItems()
         return [item.data(qt.Qt.UserRole) for item in items]
 
     def _removeSelectedObjs(self, *args, **kwargs):
         for tomo_obj in self.selectedTomoObjects():
-            self._newSerieWidget.removeTomoObjToCurrentSerie(tomo_obj)
+            self._newSeriesWidget.removeTomoObjToCurrentSeries(tomo_obj)
 
     def _addSelectedObjs(self, *args, **kwargs):
         for tomo_obj in self.selectedTomoObjects():
-            self._newSerieWidget.addTomoObjToCurrentSerie(tomo_obj)
+            self._newSeriesWidget.addTomoObjToCurrentSeries(tomo_obj)
 
     def _updateTomoObjInfos(self, *args, **kwargs):
         # should
@@ -597,23 +573,23 @@ class SerieManualFromTomoObj(qt.QWidget):
             self._tomoObjInfos.setTomoObj(None)
 
     # expose API
-    def setSerie(self, serie: Serie):
-        self._newSerieWidget.setSerie(serie=serie)
+    def setSeries(self, series: Series):
+        self._newSeriesWidget.setSeries(series=series)
 
-    def getSerie(self, *args, **kwargs) -> Serie:
-        return self._newSerieWidget.getSerie(*args, **kwargs)
+    def getSeries(self, *args, **kwargs) -> Series:
+        return self._newSeriesWidget.getSeries(*args, **kwargs)
 
     def addTomoObj(self, tomo_obj):
         self._tomoObjList.add(tomo_obj)
 
-    def addToCurrentSerie(self, tomo_obj):
-        self._newSerieWidget.addTomoObjToCurrentSerie(tomo_obj)
+    def addToCurrentSeries(self, tomo_obj):
+        self._newSeriesWidget.addTomoObjToCurrentSeries(tomo_obj)
 
-    def setSerieName(self, name: str):
-        self._newSerieWidget.setSerieName(name=name)
+    def setSeriesName(self, name: str):
+        self._newSeriesWidget.setSeriesName(name=name)
 
 
-class NewSerieWidget(qt.QWidget):
+class NewSeriesWidget(qt.QWidget):
     sigNameChanged = qt.Signal()
     """Emit when serie name changed"""
 
@@ -622,7 +598,7 @@ class NewSerieWidget(qt.QWidget):
     Emit when the serie has been updated by the tree
     """
 
-    DEFAULT_SERIE_NAME = "my_serie"
+    DEFAULT_SERIES_NAME = "my_series"
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
@@ -630,12 +606,14 @@ class NewSerieWidget(qt.QWidget):
 
         self._nameWidget = qt.QWidget(self)
         self._nameWidget.setLayout(qt.QHBoxLayout())
-        self._nameWidget.layout().addWidget(qt.QLabel("serie name", self))
-        self._nameQLE = qt.QLineEdit(self.DEFAULT_SERIE_NAME, self)
+        self._nameWidget.layout().addWidget(qt.QLabel("series name", self))
+        self._nameQLE = qt.QLineEdit(self.DEFAULT_SERIES_NAME, self)
         self._nameWidget.layout().addWidget(self._nameQLE)
         self.layout().addWidget(self._nameWidget)
 
-        self._serieTree = _SerieDefinitionTree(self, serie_name=self.DEFAULT_SERIE_NAME)
+        self._serieTree = _SeriesDefinitionTree(
+            self, serie_name=self.DEFAULT_SERIES_NAME
+        )
         self.layout().addWidget(self._serieTree)
 
         # Signal / slot connection
@@ -643,17 +621,17 @@ class NewSerieWidget(qt.QWidget):
         self._serieTree.sigUpdated.connect(self.sigUpdated)
         self._nameQLE.textChanged.connect(self._nameChangedOnQLE)
 
-    def setSerie(self, serie: Serie) -> None:
+    def setSeries(self, series: Series) -> None:
         with blockSignals(self._nameQLE):
-            self._nameQLE.setText(serie.name)
-        self._serieTree.setSerie(serie=serie)
+            self._nameQLE.setText(series.name)
+        self._serieTree.setSeries(series=series)
 
-    def getSerie(self, *args, **kwargs) -> Serie:
-        return self._serieTree.getSerie(*args, **kwargs)
+    def getSeries(self, *args, **kwargs) -> Series:
+        return self._serieTree.getSeries(*args, **kwargs)
 
     def _nameChangedOnQLE(self, name):
         with blockSignals(self._serieTree):
-            self._serieTree.setSerieName(name)
+            self._serieTree.setSeriesName(name)
         self.sigNameChanged.emit()
 
     def _handleItemUpdate(self, item, column):
@@ -663,35 +641,36 @@ class NewSerieWidget(qt.QWidget):
             self.blockSignals(old)
         self.sigUpdated.emit()
 
-    def addTomoObjToCurrentSerie(self, tomo_obj: TomwerObject):
+    def addTomoObjToCurrentSeries(self, tomo_obj: TomwerObject):
         assert isinstance(
             tomo_obj, TomwerObject
         ), f"invalid type {type(tomo_obj)}. {TomwerObject} expected"
         self._serieTree.addTomoObj(tomo_obj)
 
-    def removeTomoObjToCurrentSerie(self, tomo_obj: TomwerObject):
+    def removeTomoObjToCurrentSeries(self, tomo_obj: TomwerObject):
         assert isinstance(
             tomo_obj, TomwerObject
         ), f"invalid type {type(tomo_obj)}. {TomwerObject} expected"
         self._serieTree.removeTomoObj(tomo_obj)
 
-    def getSerieName(self) -> str:
-        return self._serieTree.getSerieName()
+    def getSeriesName(self) -> str:
+        return self._serieTree.getSeriesName()
 
-    def setSerieName(self, name: str):
-        self._serieTree.setSerieName(name=name)
+    def setSeriesName(self, name: str):
+        self._serieTree.setSeriesName(name=name)
 
 
-class SerieManualDefinitionDialog(qt.QDialog):
+class SeriesManualDefinitionDialog(qt.QDialog):
     """Dialog to define a serie manually"""
 
     sigUpdated = qt.Signal()
+    """emit when serie is updated"""
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
 
-        self._newSerieWidget = NewSerieWidget(self)
+        self._newSeriesWidget = NewSeriesWidget(self)
 
         self._buttons = qt.QDialogButtonBox(parent=self)
 
@@ -711,34 +690,34 @@ class SerieManualDefinitionDialog(qt.QDialog):
         self.layout().addWidget(self._buttons)
 
         # connect signal / slot
-        self._newSerieWidget.sigNameChanged.connect(self._nameChanged)
-        self._newSerieWidget.sigUpdated.connect(self.sigUpdated)
+        self._newSeriesWidget.sigNameChanged.connect(self._nameChanged)
+        self._newSeriesWidget.sigUpdated.connect(self.sigUpdated)
         self._addScanButton.clicked.connect(self.addScanFromFileDialog)
         self._removeSelectedButton.clicked.connect(self.removeSelectedTomoObjs)
-        self._clearButton.clicked.connect(self.clearSerie)
+        self._clearButton.clicked.connect(self.clearSeries)
 
     @property
     def n_tomo_objs(self):
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         return serieTree.n_tomo_objs
 
     def _nameChanged(self, new_name):
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         with blockSignals(self._serieTree):
-            serieTree.setSerieName(name=new_name)
+            serieTree.setSeriesName(name=new_name)
         self.sigUpdated.emit()
 
-    def setSerieName(self, name: str):
-        self._newSerieWidget.setSerieName(name=name)
+    def setSeriesName(self, name: str):
+        self._newSeriesWidget.setSeriesName(name=name)
 
-    def getSerieName(self) -> str:
-        return self._newSerieWidget.getSerieName()
+    def getSeriesName(self) -> str:
+        return self._newSeriesWidget.getSeriesName()
 
-    def setSerie(self, serie: Serie) -> None:
-        self._newSerieWidget.setSerie(serie)
+    def setSeries(self, series: Series) -> None:
+        self._newSeriesWidget.setSeries(series)
 
-    def getSerie(self, *args, **kwargs) -> Serie:
-        return self._newSerieWidget.getSerie(*args, **kwargs)
+    def getSeries(self, *args, **kwargs) -> Series:
+        return self._newSeriesWidget.getSeries(*args, **kwargs)
 
     def addScanFromFileDialog(self) -> None:
         dialog = QDataDialog(self, multiSelection=True)
@@ -751,70 +730,70 @@ class SerieManualDefinitionDialog(qt.QDialog):
         for folder in foldersSelected:
             self.addScanFromNxFile(file_=folder, entry=None)
 
-    def addScanFromNxFile(self, file_: str, entry: Optional[str] = None):
-        serieTree = self._newSerieWidget._serieTree
+    def addScanFromNxFile(self, file_: str, entry: str | None = None):
+        serieTree = self._newSeriesWidget._serieTree
         return serieTree.addScanFromNxFile(file_=file_, entry=entry)
 
     def removeSelectedTomoObjs(self) -> None:
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         return serieTree.removeSelectedTomoObjs()
 
     def getSelectedTomoObjs(self) -> tuple:
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         return serieTree.getSelectedTomoObjs()
 
     def setSelectedTomoObjs(self, scans: Iterable) -> None:
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         serieTree.setSelectedTomoObjs(objs=scans)
 
     def addTomoObj(self, scan: TomwerScanBase) -> None:
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         return serieTree.addTomoObj(tomo_obj=scan)
 
     def removeTomoObj(self, scan: TomwerScanBase) -> None:
-        serieTree = self._newSerieWidget._serieTree
+        serieTree = self._newSeriesWidget._serieTree
         serieTree.removeTomoObj(tomo_obj=scan)
 
-    def clearSerie(self) -> None:
-        serieTree = self._newSerieWidget._serieTree
+    def clearSeries(self) -> None:
+        serieTree = self._newSeriesWidget._serieTree
         serieTree.clearTomoObjs()
 
 
-class SerieAutomaticDefinitionWidget(qt.QWidget):
+class SeriesAutomaticDefinitionWidget(qt.QWidget):
     pass
 
 
-class SerieTree(qt.QWidget):
+class SeriesTree(qt.QWidget):
     """
-    Widget used to define a scan serie from a list of scans.
+    Widget used to define a scan series from a list of scans.
     """
 
     def __init__(self, parent=None, scans=tuple()) -> None:
         self._series = {}
-        # associated serie name (key) to tuple (serie, QTreeWidgetItem)
+        # associated series name (key) to tuple (series, QTreeWidgetItem)
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
         self._tree = qt.QTreeWidget(self)
         self._tree.setSelectionMode(qt.QAbstractItemView.MultiSelection)
         self._tree.setColumnCount(2)
-        self._tree.setHeaderLabels(("serie", "scan ids"))
+        self._tree.setHeaderLabels(("series", "scan ids"))
         self.layout().addWidget(self._tree)
 
         # set up
-        [self.addSerie(scan) for scan in scans]
+        [self.addSeries(scan) for scan in scans]
 
-    def addSerie(self, serie: Serie):
-        if not isinstance(serie, Serie):
+    def addSeries(self, series: Series):
+        if not isinstance(series, Series):
             raise TypeError(
-                f"{serie} is expected to be an instance of {Serie} not {type(serie)}"
+                f"{series} is expected to be an instance of {Series} not {type(series)}"
             )
-        if serie.name in self._series:
-            self.removeSerie(self._series[serie.name][0])
+        if series.name in self._series:
+            self.removeSeries(self._series[series.name][0])
 
         root_item = qt.QTreeWidgetItem(self._tree)
-        root_item.setText(0, serie.name)
-        self._series[serie.name] = (serie, root_item)
-        for obj in serie:
+        root_item.setText(0, series.name)
+        self._series[series.name] = (series, root_item)
+        for obj in series:
             scan_item = qt.QTreeWidgetItem(root_item)
             if isinstance(obj, TomwerObject):
                 text = obj.get_identifier().to_str()
@@ -823,13 +802,13 @@ class SerieTree(qt.QWidget):
             scan_item.setText(1, text)
             scan_item.setFlags(qt.Qt.NoItemFlags)
 
-    def removeSerie(self, serie: Serie):
-        if not isinstance(serie, Serie):
+    def removeSeries(self, series: Series):
+        if not isinstance(series, Series):
             raise TypeError(
-                f"{serie} is expected to be an instance of {Serie} not {type(serie)}"
+                f"{series} is expected to be an instance of {Series} not {type(series)}"
             )
-        if serie.name in self._series:
-            _, serie_item = self._series.pop(serie.name)
+        if series.name in self._series:
+            _, serie_item = self._series.pop(series.name)
             root = self._tree.invisibleRootItem()
             root.removeChild(serie_item)
 
@@ -848,35 +827,35 @@ class SerieTree(qt.QWidget):
     def setSelectedSeries(self, series):
         self.clearSelection()
         for serie in series:
-            serie_item = self._getSerieItem(serie)
+            serie_item = self._getSeriesItem(serie)
             if serie_item is not None:
                 serie_item.setSelected(True)
 
-    def _getSerieItem(self, serie: Serie) -> Optional[qt.QTreeWidgetItem]:
-        if not isinstance(serie, Serie):
+    def _getSeriesItem(self, series: Series) -> qt.QTreeWidgetItem | None:
+        if not isinstance(series, Series):
             raise TypeError(
-                f"serie is expected to be an instance of {Serie} not {type(serie)}"
+                f"serie is expected to be an instance of {Series} not {type(series)}"
             )
-        return self._series.get(serie.name, (None, None))[1]
+        return self._series.get(series.name, (None, None))[1]
 
     def getSelectedSeries(self) -> tuple():
         """return selected series"""
         selected = []
-        for _, (serie, item) in self._series.items():
+        for _, (series, item) in self._series.items():
             if item.isSelected():
-                selected.append(serie)
+                selected.append(series)
         return tuple(selected)
 
     def removeSelected(self) -> None:
-        for serie in self.getSelectedSeries():
-            self.removeSerie(serie)
+        for series in self.getSelectedSeries():
+            self.removeSeries(series)
 
 
-class SerieHistoryDialog(qt.QDialog):
-    sigSerieSend = qt.Signal(Serie)
+class SeriesHistoryDialog(qt.QDialog):
+    sigSeriesSend = qt.Signal(Series)
     """signal emit when a serie has been selected by the user"""
 
-    sigEditSerie = qt.Signal(Serie)
+    sigEditSeries = qt.Signal(Series)
     """Signal emit when user request to edit a serie"""
 
     sigHistoryUpdated = qt.Signal()
@@ -886,7 +865,7 @@ class SerieHistoryDialog(qt.QDialog):
         super().__init__(parent)
         self.setLayout(qt.QVBoxLayout())
 
-        self._serieList = SerieTree(self)
+        self._serieList = SeriesTree(self)
         self.layout().addWidget(self._serieList)
 
         self._buttons = qt.QDialogButtonBox(parent=self)
@@ -911,15 +890,15 @@ class SerieHistoryDialog(qt.QDialog):
         self._clearButton.clicked.connect(self.clearSelection)
         self._editButton.clicked.connect(self.editSelected)
 
-    def addSerie(self, serie: Serie):
+    def addSeries(self, serie: Series):
         old = self.blockSignals(True)
-        self._serieList.addSerie(serie)
+        self._serieList.addSeries(serie)
         self.blockSignals(old)
         self.sigHistoryUpdated.emit()
 
-    def removeSerie(self, serie: Serie):
+    def removeSeries(self, serie: Series):
         old = self.blockSignals(True)
-        self._serieList.removeSerie(serie)
+        self._serieList.removeSeries(serie)
         self.blockSignals(old)
         self.sigHistoryUpdated.emit()
 
@@ -934,7 +913,7 @@ class SerieHistoryDialog(qt.QDialog):
 
     def sendSelected(self):
         for serie in self.getSelectedSeries():
-            self.sigSerieSend.emit(serie)
+            self.sigSeriesSend.emit(serie)
 
     def editSelected(self):
         selected = self.getSelectedSeries()
@@ -944,7 +923,7 @@ class SerieHistoryDialog(qt.QDialog):
             _logger.warning(
                 "more than one serie selected for edition. Will only edit the first one"
             )
-        self.sigEditSerie.emit(selected[0])
+        self.sigEditSeries.emit(selected[0])
 
     def removeSelected(self):
         old = self.blockSignals(True)