ert 18.0.9__py3-none-any.whl → 19.0.0__py3-none-any.whl

ert/data/_measured_data.py

@@ -141,13 +141,14 @@ class MeasuredData:
 
         # Pandas differentiates vs int and str keys.
         # Legacy-wise we use int keys for realizations
-        pddf.rename(
-            columns={str(k): int(k) for k in active_realizations},
-            inplace=True,
+        pddf = (
+            pddf.rename(
+                columns={str(k): int(k) for k in active_realizations},
+            )
+            .set_index(["observation_key", "key_index"])
+            .transpose()
         )
 
-        pddf = pddf.set_index(["observation_key", "key_index"]).transpose()
-
         return pddf
 
 

ert/ensemble_evaluator/config.py

@@ -27,6 +27,7 @@ class EvaluatorServerConfig:
         use_token: bool = True,
         host: str | None = None,
         use_ipc_protocol: bool = True,
+        prioritize_private_ip_address: bool = False,
     ) -> None:
         self.host: str | None = host
         self.router_port: int | None = None
@@ -50,7 +51,7 @@ class EvaluatorServerConfig:
         if use_ipc_protocol:
             self.uri = f"ipc:///tmp/socket-{uuid.uuid4().hex[:8]}"
         elif self.host is None:
-            self.host = get_ip_address()
+            self.host = get_ip_address(prioritize_private_ip_address)
 
         if use_token:
             self.server_public_key, self.server_secret_key = zmq.curve_keypair()

ert/field_utils/field_utils.py

@@ -238,7 +238,7 @@ def read_field(
         ext = path.suffix
         raise ValueError(f'Could not read {field_path}. Unrecognized suffix "{ext}"')
 
-    return np.ma.MaskedArray(data=values, fill_value=np.nan)  # type: ignore
+    return np.ma.MaskedArray(data=values, fill_value=np.nan)
 
 
 def save_field(

ert/field_utils/roff_io.py

@@ -23,7 +23,7 @@ def export_roff(
     binary: bool,
 ) -> None:
     dimensions = data.shape
-    data = np.flip(data, -1).ravel()  # type: ignore
+    data = np.flip(data, -1).ravel()
     data = data.astype(np.float32).filled(RMS_UNDEFINED_FLOAT)  # type: ignore
     if not np.isfinite(data).all():
         raise ValueError(

ert/gui/__init__.py

@@ -20,12 +20,15 @@ else:
 
 def is_high_contrast_mode() -> bool:
     app = cast(QWidget, QApplication.instance())
-    return app.palette().color(QPalette.ColorRole.Window).lightness() > 245
+    return (
+        app is not None
+        and app.palette().color(QPalette.ColorRole.Window).lightness() > 245
+    )
 
 
 def is_dark_mode() -> bool:
     app = cast(QWidget, QApplication.instance())
-    return app.palette().base().color().value() < 70
+    return app is not None and app.palette().base().color().value() < 70
 
 
 __version__ = ert.shared.__version__

ert/gui/ertnotifier.py

@@ -74,7 +74,7 @@ class ErtNotifier(QObject):
     @Slot()
     def emitErtChange(self) -> None:
         if self._storage is not None:
-            self._storage.refresh()
+            self._storage.reload()
 
         self.ertChanged.emit()
 

ert/gui/ertwidgets/pathchooser.py

@@ -83,7 +83,6 @@ class PathChooser(QWidget):
             if self._model.pathMustExist():
                 valid = False
                 message = PathChooser.PATH_DOES_NOT_EXIST_MSG
-            # todo: check if new (non-existing) file has directory or file format?
         elif path_exists:
             if self._model.pathMustBeExecutable() and is_file and not is_executable:
                 valid = False
@@ -122,8 +121,6 @@ class PathChooser(QWidget):
 
     def selectPath(self) -> None:
         """Pops up the 'select a file/directory' dialog"""
-        # todo: This probably needs some reworking to work properly with
-        # different scenarios... (file + dir)
         self._editing = True
         current_directory = self.getPath()
 

ert/gui/ertwidgets/suggestor/suggestor.py

@@ -19,9 +19,11 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui import is_dark_mode
 
+from .. import CopyButton
 from ._colors import BLUE_TEXT
 from ._suggestor_message import SuggestorMessage
 
@@ -105,6 +107,32 @@ QPushButton:hover {{
 """
 
 
+class _CopyAllButton(CopyButton):
+    def __init__(
+        self,
+        errors: list[ErrorInfo],
+        warnings: list[WarningInfo],
+        deprecations: list[WarningInfo],
+    ) -> None:
+        super().__init__()
+        self.setText(" Copy all messages")
+        self.all_messages = "\n\n".join(
+            [
+                f"{info.message}" + (f"\n{info.location()}" if info.location() else "")
+                for info in (errors + warnings + deprecations)
+            ]
+        )
+        self.setStyleSheet(SECONDARY_BUTTON_STYLE)
+
+    @override
+    def copy(self) -> None:
+        logger.info(
+            "Copy all button in Suggestor used. "
+            f"Copied {len(self.all_messages)} characters"
+        )
+        self.copy_text(self.all_messages)
+
+
 class Suggestor(QWidget):
     def __init__(
         self,
@@ -145,7 +173,24 @@ class Suggestor(QWidget):
             data_layout.addWidget(self._help_panel(help_links))
         self.__layout.addWidget(data_widget)
 
-        self.__layout.addWidget(self._action_buttons())
+        action_buttons = QWidget(parent=self)
+        action_buttons_layout = QHBoxLayout()
+        action_buttons_layout.setContentsMargins(0, 24, 0, 0)
+
+        if any([errors, warnings, deprecations]):
+            action_buttons_layout.addWidget(
+                _CopyAllButton(errors, warnings, deprecations)
+            )
+
+        action_buttons_layout.addStretch()
+
+        if continue_action:
+            action_buttons_layout.addWidget(self._continue_button())
+
+        action_buttons_layout.addWidget(self._close_button())
+
+        action_buttons.setLayout(action_buttons_layout)
+        self.__layout.addWidget(action_buttons)
 
     def _help_panel(self, help_links: dict[str, str]) -> QFrame:
         help_button_frame = QFrame(parent=self)
@@ -204,35 +249,23 @@ class Suggestor(QWidget):
         area_layout.addWidget(self._messages(errors, warnings, deprecations))
         return problem_area
 
-    def _action_buttons(self) -> QWidget:
-        def run_pressed() -> None:
-            assert self._continue_action
-            self._continue_action()
-            self.close()
-
-        buttons = QWidget(parent=self)
-        buttons_layout = QHBoxLayout()
-        buttons_layout.insertStretch(-1, -1)
-        buttons_layout.setContentsMargins(0, 24, 0, 0)
-
-        give_up = QPushButton("Close")
-        give_up.setObjectName("close_button")
-        give_up.setStyleSheet(BUTTON_STYLE)
-        give_up.pressed.connect(self.close)
-
-        if self._continue_action:
-            run = QPushButton("Open ERT")
-            run.setStyleSheet(BUTTON_STYLE)
-            run.setObjectName("run_ert_button")
-            run.pressed.connect(run_pressed)
-            buttons_layout.addWidget(run)
-
-            give_up.setStyleSheet(SECONDARY_BUTTON_STYLE)
-
-        buttons_layout.addWidget(give_up)
-        buttons.setLayout(buttons_layout)
-
-        return buttons
+    def _continue_button(self) -> QWidget:
+        assert self._continue_action
+        continue_button = QPushButton("Open ERT")
+        continue_button.setStyleSheet(BUTTON_STYLE)
+        continue_button.setObjectName("run_ert_button")
+        continue_button.pressed.connect(self._continue_action)
+        continue_button.pressed.connect(self.close)
+        return continue_button
+
+    def _close_button(self) -> QPushButton:
+        close_button = QPushButton("Close")
+        close_button.setObjectName("close_button")
+        close_button.pressed.connect(self.close)
+        close_button.setStyleSheet(
+            SECONDARY_BUTTON_STYLE if self._continue_action else BUTTON_STYLE
+        )
+        return close_button
 
     def _messages(
         self,

ert/gui/main.py

@@ -14,7 +14,7 @@ from signal import SIG_DFL, SIGINT, signal
 from opentelemetry.trace import Status, StatusCode
 from PyQt6.QtCore import QDir
 from PyQt6.QtGui import QIcon
-from PyQt6.QtWidgets import QApplication, QWidget
+from PyQt6.QtWidgets import QApplication, QMessageBox, QWidget
 
 from ert.config import (
     ErrorInfo,
@@ -33,8 +33,8 @@ from ert.storage import (
     ErtStorageException,
     LocalStorage,
     local_storage_set_ert_config,
-    open_storage,
 )
+from ert.storage.local_storage import _LOCAL_STORAGE_VERSION, _storage_version
 from ert.trace import trace, tracer
 
 from .ertwidgets import Suggestor
@@ -164,9 +164,31 @@ def _start_initial_gui_window(
     if ert_config is not None:
         try:
             if LocalStorage.check_migration_needed(Path(ert_config.ens_path)):
-                # Open in write mode to initialize the storage, so that
-                # dark storage can be mounted onto it
-                open_storage(ert_config.ens_path, mode="w").close()
+                storage_version = _storage_version(Path(ert_config.ens_path))
+                current_version = _LOCAL_STORAGE_VERSION
+
+                migrate_dialog = QMessageBox.warning(
+                    None,
+                    f"Migrate storage to version {current_version}?",
+                    f"Ert storage is version {storage_version} and needs to be migrated"
+                    f" to version {current_version} to be compatible with the current"
+                    f" version of Ert\n\n"
+                    f"After migration, this storage can only be opened with current or"
+                    f" later versions of Ert\n\n"
+                    "Do you wish to continue migrating storage?\n",
+                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                )
+
+                if migrate_dialog == QMessageBox.StandardButton.Yes:
+                    logger.info(
+                        f"Migrating from version {storage_version} to"
+                        f" version {current_version}"
+                    )
+                else:
+                    logger.info("Storage migration cancelled by user")
+                    os._exit(0)
+
+                LocalStorage.perform_migration(Path(ert_config.ens_path))
             storage_path = ert_config.ens_path
         except ErtStorageException as err:
             validation_messages.errors.append(

ert/gui/main_window.py

@@ -31,7 +31,6 @@ from ert.gui.find_ert_info import find_ert_info
 from ert.gui.simulation import ExperimentPanel
 from ert.gui.simulation.run_dialog import RunDialog
 from ert.gui.tools.event_viewer import EventViewerTool, GUILogHandler
-from ert.gui.tools.export import ExportTool
 from ert.gui.tools.load_results import LoadResultsTool
 from ert.gui.tools.manage_experiments import ManageExperimentsPanel
 from ert.gui.tools.plot.plot_window import PlotWindow
@@ -373,10 +372,6 @@ class ErtMainWindow(QMainWindow):
             tools_menu.addAction(self._event_viewer_tool.getAction())
             self.close_signal.connect(self._event_viewer_tool.close_wnd)
 
-        self.export_tool = ExportTool(self.ert_config, self.notifier)
-        self.export_tool.setParent(self)
-        tools_menu.addAction(self.export_tool.getAction())
-
         self.workflows_tool = WorkflowsTool(self.ert_config, self.notifier)
         self.workflows_tool.setParent(self)
         tools_menu.addAction(self.workflows_tool.getAction())

ert/gui/simulation/experiment_panel.py

@@ -55,9 +55,15 @@ def create_md_table(kv: dict[str, str], output: str) -> str:
 
 
 def get_simulation_thread(
-    model: Any, rerun_failed_realizations: bool = False, use_ipc_protocol: bool = False
+    model: Any,
+    rerun_failed_realizations: bool = False,
+    use_ipc_protocol: bool = False,
+    prioritize_private_ip_address: bool = False,
 ) -> ErtThread:
-    evaluator_server_config = EvaluatorServerConfig(use_ipc_protocol=use_ipc_protocol)
+    evaluator_server_config = EvaluatorServerConfig(
+        use_ipc_protocol=use_ipc_protocol,
+        prioritize_private_ip_address=prioritize_private_ip_address,
+    )
 
     def run() -> None:
         model.api.start_simulations_thread(
@@ -368,7 +374,9 @@ class ExperimentPanel(QWidget):
             run_path=Path(self.config.runpath_config.runpath_format_string),
             storage_path=self._notifier.storage.path,
         )
-        self._dialog.set_queue_system_name(model.queue_config.queue_system)
+        self._dialog.queue_system.setText(
+            f"Queue system:\n{model.queue_config.queue_system.formatted_name}"
+        )
         self.experiment_started.emit(self._dialog)
         self._simulation_done = False
         self.run_button.setEnabled(self._simulation_done)
@@ -379,6 +387,7 @@ class ExperimentPanel(QWidget):
                 rerun_failed_realizations,
                 use_ipc_protocol=self.config.queue_config.queue_system
                 == QueueSystem.LOCAL,
+                prioritize_private_ip_address=self.config.prioritize_private_ip_address,
             )
             self._dialog.setup_event_monitoring(rerun_failed_realizations)
             simulation_thread.start()

ert/gui/simulation/run_dialog.py

@@ -4,7 +4,7 @@ import logging
 from datetime import datetime
 from pathlib import Path
 from queue import SimpleQueue
-from typing import assert_never, cast
+from typing import cast
 
 import humanize
 from PyQt6.QtCore import QModelIndex, QSize, Qt, QThread, QTimer
@@ -32,7 +32,7 @@ from PyQt6.QtWidgets import (
 from typing_extensions import override
 
 from _ert.events import EnsembleEvaluationWarning
-from ert.config import ErrorInfo, QueueSystem, WarningInfo
+from ert.config import ErrorInfo, WarningInfo
 from ert.ensemble_evaluator import (
     EndEvent,
     FullSnapshotEvent,
@@ -666,20 +666,6 @@ class RunDialog(QFrame):
             self.rerun_failed_realizations_experiment.emit()
             self.set_show_warning_button_to_initial_state()
 
-    def set_queue_system_name(self, queue_system: QueueSystem) -> None:
-        match queue_system:
-            case QueueSystem.LSF:
-                formatted_queue_system = "LSF"
-            case QueueSystem.LOCAL:
-                formatted_queue_system = "Local"
-            case QueueSystem.TORQUE:
-                formatted_queue_system = "Torque/OpenPBS"
-            case QueueSystem.SLURM:
-                formatted_queue_system = "Slurm"
-            case default:
-                assert_never(default)
-        self.queue_system.setText(f"Queue system:\n{formatted_queue_system}")
-
     @override
     def hideEvent(self, event: QHideEvent | None) -> None:
         for file_dialog in self.findChildren(FileDialog):

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)