ert 17.1.9__py3-none-any.whl → 18.0.0__py3-none-any.whl

ert/gui/simulation/manual_update_panel.py

@@ -3,9 +3,9 @@ from dataclasses import dataclass
 from typing import cast
 
 import numpy as np
-from PyQt6.QtCore import Qt
+from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtCore import pyqtSlot as Slot
-from PyQt6.QtWidgets import QFormLayout, QLabel, QWidget
+from PyQt6.QtWidgets import QComboBox, QFormLayout, QLabel, QWidget
 from typing_extensions import override
 
 from ert.config import AnalysisConfig, ErrorInfo
@@ -16,11 +16,11 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     EnsembleSelector,
     StringBox,
+    Suggestor,
     TargetEnsembleModel,
 )
 from ert.gui.simulation.experiment_config_panel import ExperimentConfigPanel
-from ert.gui.suggestor import Suggestor
-from ert.mode_definitions import MANUAL_UPDATE_MODE
+from ert.mode_definitions import MANUAL_ENIF_UPDATE_MODE, MANUAL_UPDATE_MODE
 from ert.run_models.manual_update import ManualUpdate
 from ert.storage import Ensemble, RealizationStorageState
 from ert.validation import EnsembleRealizationsArgument, ProperNameFormatArgument
@@ -38,6 +38,8 @@ class Arguments:
 
 
 class ManualUpdatePanel(ExperimentConfigPanel):
+    updateMethodChanged = pyqtSignal(str)
+
     def __init__(
         self,
         run_path: str,
@@ -49,9 +51,17 @@ class ManualUpdatePanel(ExperimentConfigPanel):
         self.setObjectName("Manual_update_panel")
 
         layout = QFormLayout()
-        lab = QLabel(ManualUpdate.name())
-        lab.setAlignment(Qt.AlignmentFlag.AlignLeft)
-        layout.addRow(lab)
+        self._update_method_dropdown = QComboBox()
+        self._update_method_dropdown.addItems(
+            ["ES Update", "EnIF Update (Experimental)"]
+        )
+        self._update_method_dropdown.currentTextChanged.connect(
+            self._on_update_method_changed
+        )
+        self._update_method_dropdown.setObjectName("manual_update_method_dropdown")
+
+        layout.addRow("Update method:", self._update_method_dropdown)
+
         self._ensemble_selector = EnsembleSelector(
             notifier, show_only_with_response_data=True
         )
@@ -97,6 +107,17 @@ class ManualUpdatePanel(ExperimentConfigPanel):
         self._ensemble_selector.currentIndexChanged.connect(self._realizations_from_fs)
         self.setLayout(layout)
 
+    @property
+    def selected_update_method(self) -> str:
+        return self._update_method_dropdown.currentText()
+
+    @Slot(str)
+    def _on_update_method_changed(self, new_method: str) -> None:
+        if new_method == "ES Update":
+            self._analysis_module_edit.show()
+        else:
+            self._analysis_module_edit.hide()
+
     @override
     def isConfigurationValid(self) -> bool:
         return (
@@ -107,7 +128,9 @@ class ManualUpdatePanel(ExperimentConfigPanel):
     @override
     def get_experiment_arguments(self) -> Arguments:
         return Arguments(
-            mode=MANUAL_UPDATE_MODE,
+            mode=MANUAL_UPDATE_MODE
+            if self.selected_update_method == "ES Update"
+            else MANUAL_ENIF_UPDATE_MODE,
             ensemble_id=str(
                 cast(Ensemble, self._ensemble_selector.selected_ensemble).id
             ),

ert/gui/simulation/multiple_data_assimilation_panel.py

@@ -18,14 +18,14 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     EnsembleSelector,
     StringBox,
+    Suggestor,
     TargetEnsembleModel,
     TextModel,
     ValueModel,
+    get_parameters_button,
 )
-from ert.gui.ertwidgets.parameterviewer import get_parameters_button
-from ert.gui.suggestor import Suggestor
 from ert.mode_definitions import ES_MDA_MODE
-from ert.run_models import MultipleDataAssimilation
+from ert.run_models import MultipleDataAssimilation, MultipleDataAssimilationConfig
 from ert.storage.realization_storage_state import RealizationStorageState
 from ert.validation import (
     ExperimentValidation,
@@ -114,7 +114,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
         self._target_ensemble_format_field.setValidator(ProperNameFormatArgument())
         layout.addRow("Target ensemble format:", self._target_ensemble_format_field)
 
-        self.weights = MultipleDataAssimilation.default_weights
+        self.weights = MultipleDataAssimilationConfig.default_weights
         self.weights_valid = True
         self._createInputForWeights(layout)
 
@@ -135,6 +135,8 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
         self._active_realizations_field.model.setValueFromMask(  # type: ignore
             active_realizations
         )
+        self._initial_active_realizations = active_realizations
+
         self._ensemble_selector = EnsembleSelector(notifier)
         self._previous_ensemble_realizations_validator = EnsembleRealizationsArgument(
             lambda: self._ensemble_selector.selected_ensemble,
@@ -215,7 +217,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
 
             self._relative_iteration_weights_box.setText(
                 self._ensemble_selector.selected_ensemble.relative_weights
-                or MultipleDataAssimilation.default_weights
+                or MultipleDataAssimilationConfig.default_weights
             )
             self._evaluate_weights_box_enabled()
 
@@ -250,9 +252,9 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
                 self._ensemble_selector.selected_ensemble is not None
                 and self._ensemble_selector.selected_ensemble.relative_weights
             )
-            or MultipleDataAssimilation.default_weights
+            or MultipleDataAssimilationConfig.default_weights
             if self._restart_box.isChecked()
-            else MultipleDataAssimilation.default_weights
+            else MultipleDataAssimilationConfig.default_weights
         )
         if self._restart_box.isChecked():
             self._active_realizations_field.setValidator(
@@ -264,7 +266,9 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
             self._active_realizations_field.setValidator(
                 self._new_ensemble_realizations_validator
             )
-            self._active_realizations_field.model.setValue(value="")
+            self._active_realizations_field.model.setValueFromMask(  # type: ignore
+                self._initial_active_realizations
+            )
 
     def _createInputForWeights(self, layout: QFormLayout) -> None:
         relative_iteration_weights_model = ValueModel(self.weights)

ert/gui/simulation/run_dialog.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from datetime import datetime
 from pathlib import Path
 from queue import SimpleQueue
 from typing import assert_never, cast
@@ -30,15 +31,18 @@ from PyQt6.QtWidgets import (
 )
 from typing_extensions import override
 
+from _ert.events import EnsembleEvaluationWarning
 from ert.config import ErrorInfo, QueueSystem, WarningInfo
 from ert.ensemble_evaluator import (
     EndEvent,
     FullSnapshotEvent,
     SnapshotUpdateEvent,
+    StartEvent,
     WarningEvent,
 )
 from ert.ensemble_evaluator import identifiers as ids
 from ert.gui.ertnotifier import ErtNotifier
+from ert.gui.ertwidgets import Suggestor
 from ert.gui.model.fm_step_list import FMStepListProxyModel
 from ert.gui.model.node import IterNode
 from ert.gui.model.real_list import RealListModel
@@ -49,7 +53,6 @@ from ert.gui.model.snapshot import (
     RealIens,
     SnapshotModel,
 )
-from ert.gui.suggestor import Suggestor
 from ert.gui.tools.file import FileDialog
 from ert.run_models import (
     RunModelAPI,
@@ -258,6 +261,7 @@ class RunDialog(QFrame):
         self._fm_step_label.setObjectName("fm_step_label")
         self._fm_step_overview = FMStepOverview(self._snapshot_model, self)
 
+        self._start_time: datetime | None = None
         self.running_time = QLabel("Running time:\n -")
         self.running_time.setMinimumWidth(150)
         self.queue_system = QLabel("")
@@ -524,9 +528,11 @@ class RunDialog(QFrame):
 
     @Slot()
     def _on_ticker(self) -> None:
-        runtime = self._run_model_api.get_runtime()
-        running_time = f"Running time: {humanize.precisedelta(runtime)}"
-        self.running_time.setText(running_time[0:14] + "\n" + running_time[14:])
+        if self._start_time:
+            humanized_runtime = humanize.precisedelta(
+                datetime.now() - self._start_time, minimum_unit="seconds", format="%d"
+            )
+            self.running_time.setText(f"Running time:\n{humanized_runtime}")
 
         maximum_memory_usage = self._snapshot_model.root.max_memory_usage
 
@@ -543,11 +549,16 @@ class RunDialog(QFrame):
     def _on_event(self, event: object) -> None:
         model = self._snapshot_model
         match event:
+            case StartEvent():
+                self._start_time = event.timestamp
             case EndEvent(failed=failed, msg=msg):
                 self.simulation_done.emit(failed, msg)
                 self._ticker.stop()
             case WarningEvent(msg=msg):
                 self.post_simulation_warnings.append(msg)
+            case EnsembleEvaluationWarning(warning_message=msg):
+                self._show_warning(msg)
+
             case FullSnapshotEvent(
                 status_count=status_count, realization_count=realization_count
             ):
@@ -650,6 +661,7 @@ class RunDialog(QFrame):
         if result == QMessageBox.StandardButton.Ok:
             self.rerun_button.setEnabled(False)
             self.kill_button.setEnabled(True)
+            self.post_simulation_warnings.clear()
             self._is_rerunning_failed_realizations = True
             self.rerun_failed_realizations_experiment.emit()
             self.set_show_warning_button_to_initial_state()
@@ -673,6 +685,15 @@ class RunDialog(QFrame):
         for file_dialog in self.findChildren(FileDialog):
             file_dialog.close()
 
+    def _show_warning(self, msg: str) -> None:
+        msg_box = QMessageBox(self)
+        msg_box.setObjectName("EnsembleEvaluationWarningBox")
+        msg_box.setIcon(QMessageBox.Icon.Warning)
+        msg_box.setWindowTitle("Ensemble Evaluation Warning")
+        msg_box.setText(msg)
+        msg_box.setStandardButtons(QMessageBox.StandardButton.Ok)
+        msg_box.show()
+
 
 # Cannot use a non-static method here as
 # it is called when the object is destroyed

ert/gui/simulation/single_test_run_panel.py

@@ -4,13 +4,13 @@ from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import QFormLayout, QLabel
 from typing_extensions import override
 
+from ert.config import AnalysisConfig, ParameterConfig
 from ert.gui.ertnotifier import ErtNotifier
 from ert.gui.ertwidgets import CopyableLabel
 from ert.mode_definitions import TEST_RUN_MODE
 from ert.run_models import SingleTestRun
 
-from ...config import AnalysisConfig, ParameterConfig
-from ..ertwidgets.parameterviewer import get_parameters_button
+from ..ertwidgets import get_parameters_button
 from ._design_matrix_panel import DesignMatrixPanel
 from .experiment_config_panel import ExperimentConfigPanel
 

ert/gui/summarypanel.py

@@ -13,7 +13,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.gui.ertwidgets.models.ertsummary import ErtSummary
+from ert.gui.ertwidgets import ErtSummary
 
 if TYPE_CHECKING:
     from ert.config import ErtConfig

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/manage_experiments/storage_info_widget.py

@@ -189,9 +189,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),
         )
@@ -418,14 +418,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

@@ -24,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 (

ert/gui/tools/plot/plot_api.py

@@ -19,7 +19,7 @@ from pandas.errors import ParserError
 from resfo_utilities import history_key
 
 from ert.config import ParameterMetadata, ResponseMetadata
-from ert.services import StorageService
+from ert.services import ErtServer
 from ert.storage.realization_storage_state import RealizationStorageState
 
 logger = logging.getLogger(__name__)
@@ -56,7 +56,7 @@ class PlotApi:
 
     @property
     def api_version(self) -> str:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             try:
                 response = client.get("/version", timeout=self._timeout)
                 self._check_response(response)
@@ -82,7 +82,7 @@ class PlotApi:
             return self._all_ensembles
 
         self._all_ensembles = []
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             try:
                 response = client.get("/experiments", timeout=self._timeout)
                 self._check_response(response)
@@ -138,7 +138,7 @@ class PlotApi:
         all_keys: dict[str, PlotApiKeyDefinition] = {}
         all_params = {}
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get("/experiments", timeout=self._timeout)
             self._check_response(response)
 
@@ -162,7 +162,7 @@ class PlotApi:
     def responses_api_key_defs(self) -> list[PlotApiKeyDefinition]:
         key_defs: dict[str, PlotApiKeyDefinition] = {}
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get("/experiments", timeout=self._timeout)
             self._check_response(response)
 
@@ -224,7 +224,7 @@ class PlotApi:
         response_key: str,
         filter_on: dict[str, Any] | None = None,
     ) -> pd.DataFrame:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get(
                 f"/ensembles/{ensemble_id}/responses/{PlotApi.escape(response_key)}",
                 headers={"accept": "application/x-parquet"},
@@ -241,7 +241,10 @@ class PlotApi:
             try:
                 df.columns = pd.to_datetime(df.columns, format="%Y-%m-%d %H:%M:%S")
             except (ParserError, ValueError):
-                df.columns = [int(s) for s in df.columns]
+                try:
+                    df.columns = [int(s) for s in df.columns]
+                except ValueError:
+                    df.columns = [float(s) for s in df.columns]
 
             try:
                 return df.astype(float)
@@ -249,7 +252,7 @@ class PlotApi:
                 return df
 
     def data_for_parameter(self, ensemble_id: str, parameter_key: str) -> pd.DataFrame:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             parameter = client.get(
                 f"/ensembles/{ensemble_id}/parameters/{PlotApi.escape(parameter_key)}",
                 headers={"accept": "application/x-parquet"},
@@ -291,7 +294,7 @@ class PlotApi:
             assert key_def.response_metadata is not None
             actual_response_key = key_def.response_metadata.response_key
             filter_on = key_def.filter_on
-            with StorageService.session(project=self.ens_path) as client:
+            with ErtServer.session(project=self.ens_path) as client:
                 response = client.get(
                     f"/ensembles/{ensemble.id}/responses/{PlotApi.escape(actual_response_key)}/observations",
                     timeout=self._timeout,
@@ -374,7 +377,7 @@ class PlotApi:
         if not ensemble:
             return np.array([])
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get(
                 f"/ensembles/{ensemble.id}/parameters/{PlotApi.escape(key)}/std_dev",
                 params={"z": z},

ert/gui/tools/plot/plot_window.py

@@ -335,6 +335,18 @@ class PlotWindow(QMainWindow):
                     handle_exception(e)
                     plot_context.history_data = None
 
+            if (
+                key_def.response_metadata is not None
+                and key_def.response_metadata.response_type == "rft"
+            ):
+                plot_context.setXLabel(key.split(":")[-1])
+                plot_context.setYLabel("TVD")
+                plot_context.depth_y_axis = True
+                for ekey, data in list(ensemble_to_data_map.items()):
+                    ensemble_to_data_map[ekey] = data.interpolate(
+                        method="linear", axis="columns"
+                    )
+
             for data in ensemble_to_data_map.values():
                 data = data.T
 

ert/gui/tools/plot/plottery/plot_config.py

@@ -88,6 +88,8 @@ class PlotConfig:
 
         self._std_dev_factor = 1  # sigma 1 is default std dev
 
+        self.depth_y_axis = False
+
     def getNumberOfColors(self) -> int:
         return len(self._line_color_cycle_colors)
 

ert/gui/tools/plot/plottery/plot_context.py

@@ -47,6 +47,14 @@ class PlotContext:
         self._y_axis: str | None = None
         self._log_scale = False
 
+    @property
+    def depth_y_axis(self) -> bool:
+        return self._plot_config.depth_y_axis
+
+    @depth_y_axis.setter
+    def depth_y_axis(self, value: bool) -> None:
+        self._plot_config.depth_y_axis = value
+
     def plotConfig(self) -> PlotConfig:
         return self._plot_config
 
@@ -93,6 +101,12 @@ class PlotContext:
             )
         self._y_axis = value
 
+    def setXLabel(self, value: str) -> None:
+        self._plot_config.setXLabel(value)
+
+    def setYLabel(self, value: str) -> None:
+        self._plot_config.setYLabel(value)
+
     @property
     def log_scale(self) -> bool:
         return self._log_scale

ert/gui/tools/plot/plottery/plots/ensemble.py

@@ -86,9 +86,16 @@ class EnsemblePlot:
         if len(data) == 1 and not style.marker:
             style.marker = "."
 
+        if plot_config.depth_y_axis:
+            x = data.to_numpy()
+            y = data.index.to_numpy()
+            axes.yaxis.set_inverted(True)
+        else:
+            y = data.to_numpy()
+            x = data.index.to_numpy()
         lines = axes.plot(
-            data.index.to_numpy(),
-            data.to_numpy(),
+            x,
+            y,
             color=style.color,
             alpha=style.alpha,
             marker=style.marker,

ert/gui/tools/plot/plottery/plots/statistics.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 from matplotlib.lines import Line2D
@@ -126,10 +126,18 @@ def _plotPercentiles(
     axes: Axes, plot_config: PlotConfig, data: DataFrame, ensemble_label: str
 ) -> None:
     style = plot_config.getStatisticsStyle("mean")
+    if plot_config.depth_y_axis:
+        axes.yaxis.set_inverted(True)
+
+    def xy_order(x: Any, y: Any) -> tuple[Any, Any]:
+        if plot_config.depth_y_axis:
+            return (y, x)
+        else:
+            return (x, y)
+
     if style.isVisible():
         axes.plot(
-            data.index.values,
-            data["Mean"].values,
+            *xy_order(data.index.values, data["Mean"].values),
             alpha=style.alpha,
             linestyle=style.line_style,
             color=style.color,
@@ -141,8 +149,7 @@ def _plotPercentiles(
     style = plot_config.getStatisticsStyle("p50")
     if style.isVisible():
         axes.plot(
-            data.index.values,
-            data["p50"].values,
+            *xy_order(data.index.values, data["p50"].values),
             alpha=style.alpha,
             linestyle=style.line_style,
             color=style.color,
@@ -153,7 +160,13 @@ def _plotPercentiles(
 
     style = plot_config.getStatisticsStyle("std")
     _plotPercentile(
-        axes, style, data.index.values, data["std+"].values, data["std-"].values, 0.5
+        axes,
+        style,
+        data.index.values,
+        data["std+"].values,
+        data["std-"].values,
+        0.5,
+        plot_config.depth_y_axis,
     )
 
     style = plot_config.getStatisticsStyle("min-max")
@@ -164,16 +177,29 @@ def _plotPercentiles(
         data["Maximum"].values,
         data["Minimum"].values,
         0.5,
+        plot_config.depth_y_axis,
     )
 
     style = plot_config.getStatisticsStyle("p10-p90")
     _plotPercentile(
-        axes, style, data.index.values, data["p90"].values, data["p10"].values, 0.5
+        axes,
+        style,
+        data.index.values,
+        data["p90"].values,
+        data["p10"].values,
+        0.5,
+        plot_config.depth_y_axis,
     )
 
     style = plot_config.getStatisticsStyle("p33-p67")
     _plotPercentile(
-        axes, style, data.index.values, data["p67"].values, data["p33"].values, 0.5
+        axes,
+        style,
+        data.index.values,
+        data["p67"].values,
+        data["p33"].values,
+        0.5,
+        plot_config.depth_y_axis,
     )
 
 
@@ -184,24 +210,39 @@ def _plotPercentile(
     top_line_data: npt.ArrayLike,
     bottom_line_data: npt.ArrayLike,
     alpha_multiplier: float,
+    inverted: bool = False,
 ) -> None:
     alpha = style.alpha
     line_style = style.line_style
     color = style.color
     marker = style.marker
 
+    def xy_order(x: Any, y: Any) -> tuple[Any, Any]:
+        if inverted:
+            return (y, x)
+        else:
+            return (x, y)
+
     if line_style == "#":
-        axes.fill_between(
-            index_values,
-            bottom_line_data,
-            top_line_data,
-            alpha=alpha * alpha_multiplier,
-            color=color,
-        )
+        if inverted:
+            axes.fill_betweenx(
+                index_values,
+                bottom_line_data,
+                top_line_data,
+                alpha=alpha * alpha_multiplier,
+                color=color,
+            )
+        else:
+            axes.fill_between(
+                index_values,
+                bottom_line_data,
+                top_line_data,
+                alpha=alpha * alpha_multiplier,
+                color=color,
+            )
     elif style.isVisible():
         axes.plot(
-            index_values,
-            bottom_line_data,
+            *xy_order(index_values, bottom_line_data),
             alpha=alpha,
             linestyle=line_style,
             color=color,
@@ -210,8 +251,7 @@ def _plotPercentile(
             markersize=style.size,
         )
         axes.plot(
-            index_values,
-            top_line_data,
+            *xy_order(index_values, top_line_data),
             alpha=alpha,
             linestyle=line_style,
             color=color,

ert/mode_definitions.py

@@ -6,6 +6,7 @@ TEST_RUN_MODE = "test_run"
 WORKFLOW_MODE = "workflow"
 EVALUATE_ENSEMBLE_MODE = "evaluate_ensemble"
 MANUAL_UPDATE_MODE = "manual_update"
+MANUAL_ENIF_UPDATE_MODE = "manual_enif_update"
 
 MODULE_MODE = {
     "EnsembleInformationFilter": ENIF_MODE,
@@ -15,4 +16,5 @@ MODULE_MODE = {
     "SingleTestRun": TEST_RUN_MODE,
     "EvaluateEnsemble": EVALUATE_ENSEMBLE_MODE,
     "ManualUpdate": MANUAL_UPDATE_MODE,
+    "ManualEnIFUpdate": MANUAL_ENIF_UPDATE_MODE,
 }

ert/plugins/__init__.py

@@ -25,7 +25,6 @@ def plugin(name: str) -> Callable[[Callable[P, Any]], Callable[P, Any]]:
             if (
                 func.__name__
                 in {
-                    "installable_jobs",
                     "job_documentation",
                     "installable_workflow_jobs",
                     "help_links",