ert 16.0.9__py3-none-any.whl → 19.0.0rc2__py3-none-any.whl

ert/gui/tools/event_viewer/panel.py

@@ -7,6 +7,7 @@ from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtGui import QCloseEvent
 from PyQt6.QtWidgets import QDialog, QPlainTextEdit, QVBoxLayout
+from typing_extensions import override
 
 from ert.gui.tools.search_bar import SearchBar
 
@@ -32,10 +33,7 @@ class _GUILogHandler(logging.Handler):
 
 
 class GUILogHandler(_Signaler):
-    """
-    Log handler which will emit a qt signal every time a
-    log is emitted
-    """
+    """Log handler which will emit a qt signal every time a log is emitted."""
 
     def __init__(self) -> None:
         super().__init__()
@@ -78,6 +76,7 @@ class EventViewerPanel(QDialog):
     def val_changed(self, value: str) -> None:
         self.text_box.appendPlainText(value)
 
+    @override
     def closeEvent(self, event: QCloseEvent | None) -> None:
         logger.info("Gui utility: EventViewer tool was used")
         super().closeEvent(event)

ert/gui/tools/event_viewer/tool.py

@@ -1,6 +1,7 @@
 from PyQt6.QtCore import QObject
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtGui import QIcon
+from typing_extensions import override
 
 from ert.gui.tools import Tool
 
@@ -21,6 +22,7 @@ class EventViewerTool(Tool, QObject):
             self.logging_window.setWindowTitle(f"Event viewer: {config_filename}")
         self.setEnabled(True)
 
+    @override
     def trigger(self) -> None:
         self.logging_window.show()
 

ert/gui/tools/load_results/load_results_panel.py

@@ -13,10 +13,10 @@ from ert.gui.ertwidgets import (
     EnsembleSelector,
     QApplication,
     StringBox,
+    Suggestor,
     TextBox,
     TextModel,
 )
-from ert.gui.suggestor import Suggestor
 from ert.run_models.run_model import captured_logs
 from ert.storage.local_ensemble import load_parameters_and_responses_from_runpath
 from ert.validation import RangeStringArgument, StringDefinition

ert/gui/tools/load_results/load_results_tool.py

@@ -2,6 +2,7 @@ import logging
 from typing import Any
 
 from PyQt6.QtGui import QIcon
+from typing_extensions import override
 
 from ert.config import ErtConfig
 from ert.gui.ertnotifier import ErtNotifier
@@ -23,6 +24,7 @@ class LoadResultsTool(Tool):
         self._notifier = notifier
         self._config = config
 
+    @override
     def trigger(self) -> None:
         if self._import_widget is None:
             self._import_widget = LoadResultsPanel(self._config, self._notifier)

ert/gui/tools/manage_experiments/export_dialog.py

@@ -0,0 +1,136 @@
+import contextlib
+from pathlib import Path
+from typing import cast
+
+import polars as pl
+from PyQt6.QtCore import (
+    Qt,
+)
+from PyQt6.QtCore import (
+    pyqtSlot as Slot,
+)
+from PyQt6.QtGui import QColor, QPalette
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFileDialog,
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class ExportDialog(QDialog):
+    """Base dialog for exporting ensemble-related data to files."""
+
+    def __init__(
+        self,
+        export_data: pl.DataFrame,
+        window_title: str = "Export data",
+        parent: QWidget | None = None,
+    ) -> None:
+        QDialog.__init__(self, parent)
+        self._export_data = export_data
+        self.setWindowTitle(window_title)
+
+        self.setWindowFlags(Qt.WindowType.Dialog)
+        self.setModal(True)
+        self.setMinimumWidth(450)
+        self.setMinimumHeight(200)
+
+        main_layout = QVBoxLayout()
+
+        file_layout = QHBoxLayout()
+        self._file_path_edit = QLineEdit(self)
+        self._file_path_edit.setPlaceholderText("Select output file...")
+        self._file_path_edit.textChanged.connect(self.validate_file)
+        browse_button = QPushButton("Browse...", self)
+        browse_button.clicked.connect(self.browse_file)
+        file_layout.addWidget(self._file_path_edit)
+        file_layout.addWidget(browse_button)
+        main_layout.addLayout(file_layout)
+
+        self._export_text_area = QTextEdit(self)
+        self._export_text_area.setReadOnly(True)
+        self._export_text_area.setFixedHeight(100)
+        main_layout.addWidget(self._export_text_area)
+
+        button_box = QDialogButtonBox(self)
+        button_box.setStandardButtons(QDialogButtonBox.StandardButton.Cancel)
+        button_box.rejected.connect(self.cancel)
+
+        self._export_button = cast(
+            QPushButton,
+            button_box.addButton("Export", QDialogButtonBox.ButtonRole.AcceptRole),
+        )
+        self._export_button.clicked.connect(self.export)
+        self._export_button.setEnabled(False)  # Initially disabled
+        main_layout.addWidget(button_box)
+
+        self.setLayout(main_layout)
+
+    @Slot()
+    def export(self) -> None:
+        self._export_text_area.insertPlainText("Exporting...\n")
+        try:
+            output_file: str = self._file_path_edit.text().strip()
+            self._export_button.setEnabled(False)
+            self._export_data.write_csv(output_file, float_precision=6)
+            self._export_text_area.insertPlainText(f"Data exported to: {output_file}\n")
+        except Exception as e:
+            self._export_text_area.insertHtml(
+                f"<span style='color: red;'>Could not export data: {e!s}</span><br>"
+            )
+        finally:
+            self._export_button.setEnabled(True)
+
+    @Slot()
+    def cancel(self) -> None:
+        self.reject()
+
+    @Slot()
+    def validate_file(self) -> None:
+        """Validation to check if the file path is not empty or invalid."""
+
+        def _set_invalid(tooltip_text: str = "Invalid file path") -> None:
+            palette = self._file_path_edit.palette()
+            palette.setColor(QPalette.ColorRole.Text, QColor("red"))
+            self._file_path_edit.setPalette(palette)
+            self._file_path_edit.setToolTip(tooltip_text)
+            self._export_button.setToolTip(tooltip_text)
+            self._export_button.setEnabled(False)
+
+        def _set_valid() -> None:
+            palette = self._file_path_edit.palette()
+            palette.setColor(QPalette.ColorRole.Text, QColor("black"))
+            self._file_path_edit.setPalette(palette)
+            self._file_path_edit.setToolTip("")
+            self._export_button.setToolTip("")
+            self._export_button.setEnabled(True)
+
+        path = Path(self._file_path_edit.text().strip())
+        if str(path) in {"", "."}:
+            _set_invalid(tooltip_text="No filename provided")
+            return
+
+        if path.is_dir():
+            _set_invalid(tooltip_text=f"'{path!s}' is an existing directory.")
+            return
+
+        with contextlib.suppress(Exception):
+            if path.parent.is_dir():
+                _set_valid()
+                return
+
+        _set_invalid()
+
+    @Slot()
+    def browse_file(self) -> None:
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Select Output File", "", "All Files (*)"
+        )
+        if file_path:
+            self._file_path_edit.setText(file_path)

ert/gui/tools/manage_experiments/manage_experiments_panel.py

@@ -12,6 +12,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui.ertwidgets import (
     CheckList,
@@ -153,6 +154,7 @@ class ManageExperimentsPanel(QTabWidget):
 
         self.addTab(panel, "Initialize from scratch")
 
+    @override
     def eventFilter(self, a0: QObject | None, a1: QEvent | None) -> bool:
         if a1 is not None and a1.type() == QEvent.Type.Close:
             self.notifier.emitErtChange()

ert/gui/tools/manage_experiments/storage_info_widget.py

@@ -1,3 +1,4 @@
+import contextlib
 import json
 from enum import IntEnum
 
@@ -6,13 +7,18 @@ import seaborn as sns
 import yaml
 from matplotlib.backends.backend_qt5agg import FigureCanvas  # type: ignore
 from matplotlib.figure import Figure
+from polars import DataFrame
 from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtWidgets import (
+    QAbstractItemView,
     QFrame,
     QHBoxLayout,
     QLabel,
+    QPushButton,
     QStackedLayout,
+    QTableWidget,
+    QTableWidgetItem,
     QTabWidget,
     QTextEdit,
     QTreeWidget,
@@ -21,8 +27,11 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ert import LibresFacade
 from ert.storage import Ensemble, Experiment, RealizationStorageState
 
+from .export_dialog import ExportDialog
+
 
 class _WidgetType(IntEnum):
     EMPTY_WIDGET = 0
@@ -42,6 +51,8 @@ class _EnsembleWidgetTabs(IntEnum):
     ENSEMBLE_TAB = 0
     STATE_TAB = 1
     OBSERVATIONS_TAB = 2
+    PARAMETERS_TAB = 3
+    MISFIT_TAB = 4
 
 
 class _ExperimentWidget(QWidget):
@@ -126,12 +137,15 @@ class _EnsembleWidget(QWidget):
 
         info_frame.setLayout(info_layout)
 
+        state_frame = QFrame()
+        state_layout = QHBoxLayout()
         self._state_text_edit = QTextEdit()
         self._state_text_edit.setReadOnly(True)
         self._state_text_edit.setObjectName("ensemble_state_text")
+        state_layout.addWidget(self._state_text_edit)
+        state_frame.setLayout(state_layout)
 
         observations_frame = QFrame()
-
         self._observations_tree_widget = QTreeWidget(self)
         self._observations_tree_widget.currentItemChanged.connect(
             self._currentItemChanged
@@ -151,15 +165,38 @@ class _EnsembleWidget(QWidget):
         observations_layout.addWidget(self._canvas)
         observations_frame.setLayout(observations_layout)
 
+        self._parameters_table = QTableWidget()
+        self._parameters_table.setEditTriggers(
+            QAbstractItemView.EditTrigger.NoEditTriggers
+        )
+        self._export_params_button = QPushButton("Export...")
+        self._export_params_button.clicked.connect(self.onClickExportParameters)
+
+        parameters_frame = self.create_export_frame(
+            self._parameters_table, self._export_params_button
+        )
+
+        self._misfit_table = QTableWidget()
+        self._export_misfit_button = QPushButton("Export...")
+        self._export_misfit_button.clicked.connect(self.onClickExportMisfit)
+
+        misfit_frame = self.create_export_frame(
+            self._misfit_table, self._export_misfit_button
+        )
+
         self._tab_widget = QTabWidget()
         self._tab_widget.insertTab(
             _EnsembleWidgetTabs.ENSEMBLE_TAB, info_frame, "Ensemble"
         )
+        self._tab_widget.insertTab(_EnsembleWidgetTabs.STATE_TAB, state_frame, "State")
         self._tab_widget.insertTab(
-            _EnsembleWidgetTabs.STATE_TAB, self._state_text_edit, "State"
+            _EnsembleWidgetTabs.OBSERVATIONS_TAB, observations_frame, "Observations"
         )
         self._tab_widget.insertTab(
-            _EnsembleWidgetTabs.OBSERVATIONS_TAB, observations_frame, "Observations"
+            _EnsembleWidgetTabs.PARAMETERS_TAB, parameters_frame, "Parameters"
+        )
+        self._tab_widget.insertTab(
+            _EnsembleWidgetTabs.MISFIT_TAB, misfit_frame, "Misfit"
         )
         self._tab_widget.currentChanged.connect(self._currentTabChanged)
 
@@ -168,6 +205,17 @@ class _EnsembleWidget(QWidget):
 
         self.setLayout(layout)
 
+    def create_export_frame(self, table: QTableWidget, button: QPushButton) -> QFrame:
+        export_frame = QFrame()
+        export_layout = QVBoxLayout()
+        vertical_header = table.verticalHeader()
+        assert vertical_header is not None
+        vertical_header.setVisible(False)
+        export_layout.addWidget(table)
+        export_layout.addWidget(button)
+        export_frame.setLayout(export_layout)
+        return export_frame
+
     def _currentItemChanged(
         self, selected: QTreeWidgetItem, _: QTreeWidgetItem
     ) -> None:
@@ -189,9 +237,9 @@ class _EnsembleWidget(QWidget):
 
         response_type, obs_for_type = next(
             (
-                (response_type, _df)
-                for response_type, _df in observations_dict.items()
-                if observation_key in _df["observation_key"]
+                (response_type, df)
+                for response_type, df in observations_dict.items()
+                if observation_key in df["observation_key"]
             ),
             (None, None),
         )
@@ -356,12 +404,53 @@ class _EnsembleWidget(QWidget):
                         0, Qt.SortOrder.AscendingOrder
                     )
 
-        for i in range(self._observations_tree_widget.topLevelItemCount()):
-            item = self._observations_tree_widget.topLevelItem(i)
-            assert item is not None
-            if item.childCount() > 0:
-                self._observations_tree_widget.setCurrentItem(item.child(0))
-                break
+            for i in range(self._observations_tree_widget.topLevelItemCount()):
+                item = self._observations_tree_widget.topLevelItem(i)
+                assert item is not None
+                if item.childCount() > 0:
+                    self._observations_tree_widget.setCurrentItem(item.child(0))
+                    break
+
+        elif index in {
+            _EnsembleWidgetTabs.PARAMETERS_TAB,
+            _EnsembleWidgetTabs.MISFIT_TAB,
+        }:
+            assert self._ensemble is not None
+
+            df: pl.DataFrame = pl.DataFrame()
+            with contextlib.suppress(Exception):
+                if index == _EnsembleWidgetTabs.PARAMETERS_TAB:
+                    df = self._ensemble.load_scalar_keys(transformed=True)
+                else:
+                    df = self.get_misfit_df()
+
+            table = (
+                self._parameters_table
+                if index == _EnsembleWidgetTabs.PARAMETERS_TAB
+                else self._misfit_table
+            )
+
+            table.setUpdatesEnabled(False)
+            table.setSortingEnabled(False)
+            table.setRowCount(df.height)
+            table.setColumnCount(df.width)
+            table.setHorizontalHeaderLabels(df.columns)
+
+            rows = df.rows()
+            for r, row in enumerate(rows):
+                for c, v in enumerate(row):
+                    table.setItem(r, c, QTableWidgetItem("" if v is None else str(v)))
+
+            table.resizeColumnsToContents()
+            table.setUpdatesEnabled(True)
+
+    def get_misfit_df(self) -> DataFrame:
+        assert self._ensemble is not None
+        df = LibresFacade.load_all_misfit_data(self._ensemble)
+        realization_column = pl.Series(df.index)
+        df = pl.from_pandas(df)
+        df.insert_column(0, realization_column)
+        return df
 
     @Slot(Ensemble)
     def setEnsemble(self, ensemble: Ensemble) -> None:
@@ -372,6 +461,22 @@ class _EnsembleWidget(QWidget):
 
         self._tab_widget.setCurrentIndex(0)
 
+    @Slot()
+    def onClickExportMisfit(self) -> None:
+        assert self._ensemble is not None
+        misfit_df = self.get_misfit_df()
+        export_dialog = ExportDialog(misfit_df, "Export misfit", parent=self)
+        export_dialog.show()
+
+    @Slot()
+    def onClickExportParameters(self) -> None:
+        assert self._ensemble is not None
+        parameters_df = self._ensemble.load_scalar_keys(transformed=True)
+        export_dialog = ExportDialog(
+            parameters_df, window_title="Export parameters", parent=self
+        )
+        export_dialog.show()
+
 
 class _RealizationWidget(QWidget):
     def __init__(self) -> None:
@@ -418,14 +523,14 @@ class _RealizationWidget(QWidget):
         )
 
         html = "<table>"
-        for name, _response_state in ensemble.get_response_state(realization).items():
-            html += f"<tr><td>{name} - {_response_state.name}</td></tr>"
+        for name, response_state in ensemble.get_response_state(realization).items():
+            html += f"<tr><td>{name} - {response_state.name}</td></tr>"
         html += "</table>"
         self._response_text_edit.setHtml(html)
 
         html = "<table>"
-        for name, _param_state in ensemble.get_parameter_state(realization).items():
-            html += f"<tr><td>{name} - {_param_state.name}</td></tr>"
+        for name, param_state in ensemble.get_parameter_state(realization).items():
+            html += f"<tr><td>{name} - {param_state.name}</td></tr>"
         html += "</table>"
         self._parameter_text_edit.setHtml(html)
 

ert/gui/tools/manage_experiments/storage_widget.py

@@ -1,5 +1,6 @@
 import logging
 from collections.abc import Callable
+from typing import cast
 
 from PyQt6.QtCore import (
     QAbstractItemModel,
@@ -23,8 +24,7 @@ from PyQt6.QtWidgets import (
 
 from ert.config import ErrorInfo, ErtConfig
 from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.ertwidgets.create_experiment_dialog import CreateExperimentDialog
-from ert.gui.suggestor import Suggestor
+from ert.gui.ertwidgets import CreateExperimentDialog, Suggestor
 from ert.storage import Ensemble, Experiment
 
 from .storage_model import (
@@ -149,7 +149,8 @@ class StorageWidget(QWidget):
         self.setLayout(layout)
 
     def _currentChanged(self, selected: QModelIndex, previous: QModelIndex) -> None:
-        idx = self._tree_view.model().mapToSource(selected)  # type: ignore
+        model = cast(_SortingProxyModel, self._tree_view.model())
+        idx = model.mapToSource(selected)
         cls = idx.internalPointer()
 
         if isinstance(cls, EnsembleModel):

ert/gui/tools/plot/customize/color_chooser.py

@@ -3,14 +3,15 @@ from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtGui import QColor, QMouseEvent, QPainter, QPaintEvent
 from PyQt6.QtWidgets import QColorDialog, QFrame
+from typing_extensions import override
 
 
 class ColorBox(QFrame):
+    """A widget that shows a colored box"""
+
     colorChanged = Signal(QColor)
     mouseRelease = Signal()
 
-    """A widget that shows a colored box"""
-
     def __init__(self, size: int = 15) -> None:
         QFrame.__init__(self)
         self.setFrameStyle(QFrame.Shape.Panel | QFrame.Shadow.Sunken)
@@ -49,6 +50,7 @@ class ColorBox(QFrame):
         self._color = new_color
         self.update()
 
+    @override
     def paintEvent(self, a0: QPaintEvent | None) -> None:
         """Paints the box"""
         painter = QPainter(self)
@@ -69,6 +71,7 @@ class ColorBox(QFrame):
 
         QFrame.paintEvent(self, a0)
 
+    @override
     def mouseReleaseEvent(self, a0: QMouseEvent | None) -> None:
         if a0:
             self.mouseRelease.emit()

ert/gui/tools/plot/customize/customize_plot_dialog.py

@@ -20,6 +20,7 @@ from PyQt6.QtWidgets import (
     QWidget,
     QWidgetAction,
 )
+from typing_extensions import override
 
 from ert.gui.tools.plot.plot_api import PlotApiKeyDefinition
 from ert.gui.tools.plot.plottery import PlotConfig, PlotConfigFactory, PlotConfigHistory
@@ -296,6 +297,7 @@ class CustomizePlotDialog(QDialog):
     def currentPlotKeyChanged(self, new_key: str | None) -> None:
         self.current_key = new_key
 
+    @override
     def keyPressEvent(self, a0: QKeyEvent | None) -> None:
         # Hide when pressing Escape instead of QDialog.keyPressEvent(KeyEscape)
         # which closes the dialog

ert/gui/tools/plot/customize/default_customization_view.py

@@ -1,5 +1,7 @@
 from typing import TYPE_CHECKING
 
+from typing_extensions import override
+
 from .customization_view import CustomizationView, WidgetProperty
 
 if TYPE_CHECKING:
@@ -57,6 +59,7 @@ class DefaultCustomizationView(CustomizationView):
             "observations", "Observations", "Toggle observations visibility."
         )
 
+    @override
     def applyCustomization(self, plot_config: "PlotConfig") -> None:
         plot_config.setTitle(self.title)
 
@@ -68,6 +71,7 @@ class DefaultCustomizationView(CustomizationView):
         plot_config.setHistoryEnabled(self.history)
         plot_config.setObservationsEnabled(self.observations)
 
+    @override
     def revertCustomization(self, plot_config: "PlotConfig") -> None:
         if not plot_config.isUnnamed():
             self.title = plot_config.title()

ert/gui/tools/plot/customize/limits_customization_view.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from PyQt6.QtGui import QDoubleValidator, QIntValidator
 from PyQt6.QtWidgets import QLabel, QLineEdit, QStackedWidget
+from typing_extensions import override
 
 from ert.gui.tools.plot.plottery import PlotContext, PlotLimits
 from ert.gui.tools.plot.widgets import ClearableLineEdit, CustomDateEdit
@@ -249,8 +250,10 @@ class LimitsCustomizationView(CustomizationView):
         self._limits_widget.switchInputOnX(x_axis_type)
         self._limits_widget.switchInputOnY(y_axis_type)
 
+    @override
     def revertCustomization(self, plot_config: PlotConfig) -> None:
         self._limits_widget.limits = plot_config.limits
 
+    @override
     def applyCustomization(self, plot_config: PlotConfig) -> None:
         plot_config.limits = self._limits_widget.limits

ert/gui/tools/plot/customize/statistics_customization_view.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, cast
 
 from PyQt6.QtWidgets import QComboBox, QHBoxLayout
+from typing_extensions import override
 
 from .customization_view import CustomizationView, WidgetProperty
 from .style_chooser import STYLESET_AREA, StyleChooser
@@ -132,6 +133,7 @@ class StatisticsCustomizationView(CustomizationView):
         style.marker = marker_style
         setattr(self, attribute_name, style)
 
+    @override
     def applyCustomization(self, plot_config: PlotConfig) -> None:
         plot_config.setStatisticsStyle("mean", self.mean_style)
         plot_config.setStatisticsStyle("p50", self.p50_style)
@@ -143,6 +145,7 @@ class StatisticsCustomizationView(CustomizationView):
         plot_config.setStandardDeviationFactor(self.std_dev_factor)
         plot_config.setDistributionLineEnabled(self.distribution_lines)
 
+    @override
     def revertCustomization(self, plot_config: PlotConfig) -> None:
         self.mean_style = plot_config.getStatisticsStyle("mean")
         self.p50_style = plot_config.getStatisticsStyle("p50")

ert/gui/tools/plot/customize/style_chooser.py

@@ -8,6 +8,7 @@ from PyQt6.QtWidgets import (
     QLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui.tools.plot.plottery import PlotStyle
 
@@ -182,6 +183,7 @@ class StyleChooser(QWidget):
         self._style.width = thickness
         self._style.size = size
 
+    @override
     def setStyle(self, style: PlotStyle) -> None:  # type: ignore
         self._style.copyStyleFrom(style)
         self._updateLineStyleAndMarker(

ert/gui/tools/plot/customize/style_customization_view.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, cast
 
 from PyQt6.QtWidgets import QHBoxLayout
+from typing_extensions import override
 
 from .color_chooser import ColorBox
 from .customization_view import CustomizationView, WidgetProperty
@@ -91,6 +92,7 @@ class StyleCustomizationView(CustomizationView):
                 color_box = self._color_boxes[index]
                 color_box.color = color_tuple
 
+    @override
     def applyCustomization(self, plot_config: "PlotConfig") -> None:
         plot_config.setDefaultStyle(self.default_style)
         plot_config.setHistoryStyle(self.history_style)
@@ -98,6 +100,7 @@ class StyleCustomizationView(CustomizationView):
         plot_config.setObservationsColor(self.observs_color)
         plot_config.setLineColorCycle(self.color_cycle)
 
+    @override
     def revertCustomization(self, plot_config: "PlotConfig") -> None:
         self.default_style = plot_config.defaultStyle()
         self.history_style = plot_config.historyStyle()

ert/gui/tools/plot/data_type_keys_widget.py

@@ -9,6 +9,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui.ertwidgets import SearchBox
 
@@ -29,6 +30,7 @@ class _LegendMarker(QWidget):
 
         self.color = color
 
+    @override
     def paintEvent(self, a0: QPaintEvent | None) -> None:
         painter = QPainter(self)
 

ert/gui/tools/plot/data_type_proxy_model.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from PyQt6.QtCore import QModelIndex, QObject, QSortFilterProxyModel, Qt
+from typing_extensions import override
 
 if TYPE_CHECKING:
     from .data_type_keys_list_model import DataTypeKeysListModel
@@ -21,6 +22,7 @@ class DataTypeProxyModel(QSortFilterProxyModel):
         self.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
         self.setSourceModel(model)
 
+    @override
     def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
         show = QSortFilterProxyModel.filterAcceptsRow(self, source_row, source_parent)
 
@@ -45,6 +47,7 @@ class DataTypeProxyModel(QSortFilterProxyModel):
 
         return show
 
+    @override
     def sourceModel(self) -> DataTypeKeysListModel:
         return QSortFilterProxyModel.sourceModel(self)  # type: ignore