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

_ert/events.py

@@ -41,10 +41,12 @@ class Id:
     ENSEMBLE_SUCCEEDED_TYPE = Literal["ensemble.succeeded"]
     ENSEMBLE_CANCELLED_TYPE = Literal["ensemble.cancelled"]
     ENSEMBLE_FAILED_TYPE = Literal["ensemble.failed"]
+    ENSEMBLE_WARNING_TYPE = Literal["ensemble.warning"]
     ENSEMBLE_STARTED: Final = "ensemble.started"
     ENSEMBLE_SUCCEEDED: Final = "ensemble.succeeded"
     ENSEMBLE_CANCELLED: Final = "ensemble.cancelled"
     ENSEMBLE_FAILED: Final = "ensemble.failed"
+    ENSEMBLE_WARNING: Final = "ensemble.warning"
     ENSEMBLE_TYPES = (
         ENSEMBLE_STARTED_TYPE
         | ENSEMBLE_FAILED_TYPE
@@ -170,6 +172,15 @@ class EnsembleCancelled(EnsembleBaseEvent):
     event_type: Id.ENSEMBLE_CANCELLED_TYPE = Id.ENSEMBLE_CANCELLED
 
 
+class EnsembleEvaluationWarning(EnsembleBaseEvent):
+    """This event is to indicate that something unexpected happened while
+    running the ensemble, and that it might be stuck in an unresponsive state.
+    """
+
+    event_type: Id.ENSEMBLE_WARNING_TYPE = Id.ENSEMBLE_WARNING
+    warning_message: str
+
+
 class EESnapshot(EnsembleBaseEvent):
     event_type: Id.EE_SNAPSHOT_TYPE = Id.EE_SNAPSHOT
     snapshot: Any
@@ -200,9 +211,15 @@ RealizationEvent = (
     | RealizationResubmit
 )
 
-EnsembleEvent = EnsembleStarted | EnsembleSucceeded | EnsembleFailed | EnsembleCancelled
+EnsembleEvent = (
+    EnsembleStarted
+    | EnsembleSucceeded
+    | EnsembleFailed
+    | EnsembleCancelled
+    | EnsembleEvaluationWarning
+)
 
-EEEvent = EESnapshot | EESnapshotUpdate
+EEEvent = EESnapshot | EESnapshotUpdate | EnsembleEvaluationWarning
 
 SnapshotInputEvent = RealizationEvent | EnsembleEvent | FMEvent
 

_ert/forward_model_runner/client.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import types
 import uuid
-from typing import Any, Self
+from typing import Self
 
 import zmq
 import zmq.asyncio
@@ -67,7 +68,10 @@ class Client:
         return self
 
     async def __aexit__(
-        self, exc_type: Any, exc_value: Any, exc_traceback: Any
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: types.TracebackType | None,
     ) -> None:
         try:
             await self.send(DISCONNECT_MSG)

_ert/forward_model_runner/fm_dispatch.py

@@ -8,6 +8,7 @@ import sys
 import time
 from collections.abc import Generator, Iterable
 from datetime import datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from _ert.forward_model_runner import reporting
@@ -19,6 +20,7 @@ from _ert.forward_model_runner.reporting.message import (
     ProcessTreeStatus,
 )
 from _ert.forward_model_runner.runner import ForwardModelRunner
+from _ert.utils import file_safe_timestamp
 
 if TYPE_CHECKING:
     from ert.config.forward_model_step import ForwardModelJSON
@@ -81,10 +83,10 @@ def _setup_logging(directory: str = "logs") -> None:
         "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
 
-    filename = (
-        f"forward-model-runner-log-{datetime.now().isoformat(timespec='minutes')}.txt"
-    )
-    csv_filename = f"memory-profile-{datetime.now().isoformat(timespec='minutes')}.csv"
+    timestamp = file_safe_timestamp(datetime.now().isoformat(timespec="minutes"))
+
+    filename = f"forward-model-runner-log-{timestamp}.txt"
+    csv_filename = f"memory-profile-{timestamp}.csv"
 
     handler = logging.FileHandler(filename=directory + "/" + filename)
     handler.setFormatter(formatter)
@@ -107,8 +109,9 @@ def _wait_for_retry() -> None:
 
 def _read_fm_description_file(retry: bool = True) -> "ForwardModelDescriptionJSON":
     try:
-        with open(FORWARD_MODEL_DESCRIPTION_FILE, encoding="utf-8") as json_file:
-            return json.load(json_file)
+        return json.loads(
+            Path(FORWARD_MODEL_DESCRIPTION_FILE).read_text(encoding="utf-8")
+        )
     except json.JSONDecodeError as e:
         raise OSError(
             "fm_dispatch failed to load JSON-file describing the forward model."

_ert/forward_model_runner/reporting/event.py

@@ -137,6 +137,7 @@ class Event(Reporter):
                 return
             except ClientConnectionError as exc:
                 logger.error(f"Failed to send event: {exc}")
+                self._reporter_exception = exc
                 return
             except queue.Empty:
                 await asyncio.sleep(0)

_ert/forward_model_runner/runner.py

@@ -40,8 +40,7 @@ class ForwardModelRunner:
     def _read_manifest(self) -> dict[str, Manifest] | None:
         if not Path("manifest.json").exists():
             return None
-        with open("manifest.json", encoding="utf-8") as f:
-            data = json.load(f)
+        data = json.loads(Path("manifest.json").read_text(encoding="utf-8"))
         return {
             name: {"type": "file", "path": str(Path(file).absolute())}
             for name, file in data.items()

_ert/utils.py

@@ -0,0 +1,12 @@
+def file_safe_timestamp(timestamp: str) -> str:
+    """
+    Convert an ISO timestamp string to a file-safe version
+
+    Keeps the date in the extended format (YYYY-MM-DD) and converts the time
+    to the basic format (HHMMSS) by removing colons. This mix is not strictly
+    ISO 8601 compliant, but it can still be parsed.
+
+    Example:
+    2025-10-10T14:30:00 -> 2025-10-10T143000
+    """
+    return str(timestamp).replace(":", "")

ert/__main__.py

@@ -12,6 +12,7 @@ import sys
 import warnings
 from argparse import ArgumentParser, ArgumentTypeError
 from collections.abc import Sequence
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
@@ -20,6 +21,7 @@ from opentelemetry.trace import Status, StatusCode
 
 import ert.shared
 from _ert.threading import set_signal_handler
+from ert.base_model_context import use_runtime_plugins
 from ert.cli.main import ErtCliError, run_cli
 from ert.config import ConfigValidationError, ErtConfig, lint_file
 from ert.logging import LOGGING_CONFIG
@@ -32,11 +34,12 @@ from ert.mode_definitions import (
     WORKFLOW_MODE,
 )
 from ert.namespace import Namespace
-from ert.plugins import ErtPluginContext, ErtRuntimePlugins
-from ert.run_models.multiple_data_assimilation import MultipleDataAssimilation
-from ert.services import StorageService, WebvizErt
+from ert.plugins import ErtRuntimePlugins, get_site_plugins, setup_site_logging
+from ert.run_models.multiple_data_assimilation import MultipleDataAssimilationConfig
+from ert.services import ErtServer, WebvizErt
+from ert.shared.status.utils import get_ert_memory_usage
 from ert.shared.storage.command import add_parser_options as ert_api_add_parser_options
-from ert.storage import ErtStorageException
+from ert.storage import ErtStorageException, ErtStoragePermissionError
 from ert.trace import trace, tracer
 from ert.validation import (
     IntegerArgument,
@@ -51,9 +54,9 @@ logger = logging.getLogger(__name__)
 
 
 def run_ert_storage(args: Namespace, _: ErtRuntimePlugins | None = None) -> None:
-    with StorageService.start_server(
+    with ErtServer.start_server(
         verbose=True,
-        project=ErtConfig.from_file(args.config).ens_path,
+        project=Path(ErtConfig.from_file(args.config).ens_path),
         parent_pid=os.getpid(),
     ) as server:
         server.wait()
@@ -68,8 +71,7 @@ def run_webviz_ert(args: Namespace, _: ErtRuntimePlugins | None = None) -> None:
         ) from err
 
     kwargs: dict[str, Any] = {"verbose": args.verbose}
-    with ErtPluginContext() as runtime_plugins:
-        ert_config = ErtConfig.with_plugins(runtime_plugins).from_file(args.config)
+    ert_config = ErtConfig.with_plugins(get_site_plugins()).from_file(args.config)
 
     os.chdir(ert_config.config_path)
     ens_path = ert_config.ens_path
@@ -78,18 +80,32 @@ def run_webviz_ert(args: Namespace, _: ErtRuntimePlugins | None = None) -> None:
     # only use the base name of the config file path
     kwargs["ert_config"] = os.path.basename(args.config)
     kwargs["project"] = os.path.abspath(ens_path)
+
+    yellow = "\x1b[33m"
+    green = "\x1b[32m"
+    bold = "\x1b[1m"
+    reset = "\x1b[0m"
+
     try:
-        with StorageService.init_service(project=os.path.abspath(ens_path)) as storage:
+        with ErtServer.init_service(project=Path(ens_path).absolute()) as storage:
             storage.wait_until_ready()
             print(
-                """
-    -----------------------------------------------------------
+                f"""
+    ---------------------------------------------------------------
+
+    {yellow}{bold}Webviz-ERT is deprecated and will be removed in the near future{reset}
+
+    {green}{bold}Plotting capabilities provided by Webviz-ERT are now available
+    using the ERT plotter{reset}
+
+    ---------------------------------------------------------------
 
     Starting up Webviz-ERT. This might take more than a minute.
 
-    -----------------------------------------------------------
+    ---------------------------------------------------------------
     """
             )
+            logger.info("Show Webviz-ert deprecation warning")
             webviz_kwargs = {
                 "experimental_mode": args.experimental_mode,
                 "verbose": args.verbose,
@@ -500,7 +516,7 @@ def get_ert_parser(parser: ArgumentParser | None = None) -> ArgumentParser:
     es_mda_parser.add_argument(
         "--weights",
         type=valid_weights,
-        default=MultipleDataAssimilation.default_weights,
+        default=MultipleDataAssimilationConfig.default_weights,
         help="Example custom relative weights: '8,4,2,1'. This means multiple data "
         "assimilation ensemble smoother will half the weight applied to the "
         "observation errors from one iteration to the next across 4 iterations.",
@@ -565,15 +581,15 @@ def get_ert_parser(parser: ArgumentParser | None = None) -> ArgumentParser:
             "--color-always",
             action="store_true",
             help="Force coloring of monitor output, which is automatically"
-            + " disabled if the output stream is not a terminal.",
+            " disabled if the output stream is not a terminal.",
             default=False,
         )
         cli_parser.add_argument(
             "--disable-monitoring",
             action="store_true",
             help="Monitoring will continuously print the status of the realisations"
-            + " classified into Waiting, Pending, Running, Failed, Finished"
-            + " and Unknown.",
+            " classified into Waiting, Pending, Running, Failed, Finished"
+            " and Unknown.",
             default=False,
         )
         cli_parser.add_argument(
@@ -597,7 +613,7 @@ def ert_parser(parser: ArgumentParser | None, args: Sequence[str]) -> Namespace:
 def log_process_usage() -> None:
     try:
         usage = resource.getrusage(resource.RUSAGE_SELF)
-        max_rss = ert.shared.status.utils.get_ert_memory_usage()
+        max_rss = get_ert_memory_usage()
 
         usage_dict: dict[str, int | float] = {
             "User time": usage.ru_utime,
@@ -636,25 +652,24 @@ def main() -> None:
 
     os.environ["ERT_LOG_DIR"] = log_dir
 
-    with open(LOGGING_CONFIG, encoding="utf-8") as conf_file:
-        config_dict = yaml.safe_load(conf_file)
-        for handler_name, handler_config in config_dict["handlers"].items():
-            if handler_name == "file":
-                handler_config["filename"] = "ert-log.txt"
-            if "ert.logging.TimestampedFileHandler" in handler_config.values():
-                handler_config["config_filename"] = args.config
-        try:
-            logging.config.dictConfig(config_dict)
-        except ValueError as err:
-            if "handler 'file'" in str(err):
-                exit_msg = (
-                    f"Could not configure log handler for files. "
-                    f"Check if you have write-access to the logs-directory ({log_dir})."
-                )
-            else:
-                exit_msg = str(err)
-            os.environ.pop("ERT_LOG_DIR")
-            sys.exit(exit_msg)
+    config_dict = yaml.safe_load(Path(LOGGING_CONFIG).read_text(encoding="utf-8"))
+    for handler_name, handler_config in config_dict["handlers"].items():
+        if handler_name == "file":
+            handler_config["filename"] = "ert-log.txt"
+        if "ert.logging.TimestampedFileHandler" in handler_config.values():
+            handler_config["config_filename"] = args.config
+    try:
+        logging.config.dictConfig(config_dict)
+    except ValueError as err:
+        if "handler 'file'" in str(err):
+            exit_msg = (
+                f"Could not configure log handler for files. "
+                f"Check if you have write-access to the logs-directory ({log_dir})."
+            )
+        else:
+            exit_msg = str(err)
+        os.environ.pop("ERT_LOG_DIR")
+        sys.exit(exit_msg)
 
     logger = logging.getLogger(__name__)
     if args.verbose:
@@ -663,9 +678,14 @@ def main() -> None:
         handler.setLevel(logging.INFO)
         root_logger.addHandler(handler)
     try:
-        with ErtPluginContext(logger=logging.getLogger()) as runtime_plugins:
+        site_plugins = get_site_plugins()
+        setup_site_logging(logging.getLogger())
+        with use_runtime_plugins(site_plugins):
             logger.info(f"Running ert with {args} in {os.getcwd()}")
-            args.func(args, runtime_plugins)
+            args.func(args, site_plugins)
+    except ErtStoragePermissionError as err:
+        logger.error(str(err))
+        sys.exit(str(err))
     except (ErtCliError, ErtStorageException) as err:
         span.set_status(Status(StatusCode.ERROR))
         span.record_exception(err)

ert/analysis/_enif_update.py

@@ -160,10 +160,14 @@ def analysis_EnIF(
         Y=S.T,
         verbose_level=5,
     )
-
+    updated_parameters = [
+        p
+        for p, config in source_ensemble.experiment.parameter_configuration.items()
+        if config.update
+    ]
     # Learn the precision matrix block-sparse over parameter groups
     Prec_u = sp.sparse.csc_matrix((0, 0), dtype=float)
-    for param_group in parameters:
+    for param_group in updated_parameters:
         config_node = source_ensemble.experiment.parameter_configuration[param_group]
         X_local = source_ensemble.load_parameters_numpy(param_group, iens_active_index)
         X_local_scaler = StandardScaler()
@@ -215,7 +219,7 @@ def analysis_EnIF(
 
     # Iterate over parameters to store the updated ensemble
     parameters_updated = 0
-    for param_group in parameters:
+    for param_group in updated_parameters:
         log_msg = f"Storing data for {param_group}.."
         logger.info(log_msg)
         progress_callback(AnalysisStatusEvent(msg=log_msg))
@@ -241,7 +245,7 @@ def analysis_EnIF(
         )
     _copy_unupdated_parameters(
         list(source_ensemble.experiment.parameter_configuration.keys()),
-        parameters,
+        updated_parameters,
         iens_active_index,
         source_ensemble,
         target_ensemble,

ert/analysis/_es_update.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import functools
 import logging
+import re
 import time
 import warnings
 from collections.abc import Callable, Iterable, Sequence
@@ -441,6 +442,12 @@ def smoother_update(
         with warnings.catch_warnings():
             original_showwarning = warnings.showwarning
 
+            ILL_CONDITIONED_RE = re.compile(
+                r"^LinAlgWarning:.*ill[- ]?conditioned\s+matrix", re.IGNORECASE
+            )
+            LIMIT_ILL_CONDITIONED_WARNING = 1000
+            illconditioned_warn_counter = 0
+
             def log_warning(
                 message: Warning | str,
                 category: type[Warning],
@@ -449,12 +456,18 @@ def smoother_update(
                 file: TextIO | None = None,
                 line: str | None = None,
             ) -> None:
-                logger.warning(
-                    f"{category.__name__}: {message} (from {filename}:{lineno})"
-                )
-                original_showwarning(
-                    message, category, filename, lineno, file=file, line=line
-                )
+                nonlocal illconditioned_warn_counter
+
+                if ILL_CONDITIONED_RE.search(str(message)):
+                    illconditioned_warn_counter += 1
+
+                if illconditioned_warn_counter < LIMIT_ILL_CONDITIONED_WARNING:
+                    logger.warning(
+                        f"{category.__name__}: {message} (from {filename}:{lineno})"
+                    )
+                    original_showwarning(
+                        message, category, filename, lineno, file=file, line=line
+                    )
 
             warnings.showwarning = log_warning
             analysis_ES(

ert/analysis/_update_commons.py

@@ -61,10 +61,19 @@ def _copy_unupdated_parameters(
 
     # Copy the non-updated parameter groups from source to target
     # for each active realization
+    complete_df: pl.DataFrame | None = None
     for parameter_group in not_updated_parameter_groups:
-        source_ensemble.experiment.parameter_configuration[
-            parameter_group
-        ].copy_parameters(source_ensemble, target_ensemble, iens_active_index)
+        data = source_ensemble.load_parameters(parameter_group, iens_active_index)
+        if isinstance(data, pl.DataFrame):
+            if complete_df is None:
+                complete_df = data
+            else:
+                complete_df = complete_df.join(data, on="realization")
+        else:
+            target_ensemble.save_parameters(dataset=data)
+
+    if complete_df is not None:
+        target_ensemble.save_parameters(complete_df)
 
 
 def _expand_wildcards(
@@ -331,11 +340,12 @@ def _all_parameters(
 ) -> npt.NDArray[np.float64]:
     """Return all parameters in assimilation problem"""
 
-    param_groups = list(ensemble.experiment.parameter_configuration.keys())
-
+    groups_to_update = [
+        k for k, v in ensemble.experiment.parameter_configuration.items() if v.update
+    ]
     param_arrays = [
         ensemble.load_parameters_numpy(param_group, iens_active_index)
-        for param_group in param_groups
+        for param_group in groups_to_update
     ]
 
     return np.vstack(param_arrays)

ert/base_model_context.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 
 @contextmanager
-def init_context(value: ErtRuntimePlugins) -> Iterator[None]:
+def use_runtime_plugins(value: ErtRuntimePlugins) -> Iterator[None]:
     token = init_context_var.set(value)  # type: ignore
     try:
         yield

ert/cli/main.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 from __future__ import annotations
 
 import contextlib
@@ -7,9 +6,11 @@ import os
 import queue
 import sys
 from collections import Counter
+from pathlib import Path
 from typing import TextIO
 
 from _ert.threading import ErtThread
+from ert.base_model_context import use_runtime_plugins
 from ert.cli.monitor import Monitor
 from ert.cli.workflow import execute_workflow
 from ert.config import ErtConfig, QueueSystem
@@ -23,10 +24,10 @@ from ert.mode_definitions import (
     WORKFLOW_MODE,
 )
 from ert.namespace import Namespace
-from ert.plugins import ErtPluginContext, ErtRuntimePlugins
+from ert.plugins import ErtRuntimePlugins, get_site_plugins
 from ert.run_models.event import StatusEvents
 from ert.run_models.model_factory import create_model
-from ert.storage import open_storage
+from ert.storage import LocalStorage, open_storage
 from ert.storage.local_storage import local_storage_set_ert_config
 
 
@@ -45,10 +46,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
     if runtime_plugins is not None:
         ert_config = ErtConfig.with_plugins(runtime_plugins).from_file(args.config)
     else:
-        with ErtPluginContext() as default_runtime_plugins:
-            ert_config = ErtConfig.with_plugins(default_runtime_plugins).from_file(
-                args.config
-            )
+        ert_config = ErtConfig.with_plugins(get_site_plugins()).from_file(args.config)
 
     local_storage_set_ert_config(ert_config)
     counter_fm_steps = Counter(fms.name for fms in ert_config.forward_model_steps)
@@ -90,18 +88,25 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
             )
 
     if args.mode == WORKFLOW_MODE:
-        with open_storage(ert_config.ens_path, "w") as storage:
+        path = Path(ert_config.ens_path)
+        if LocalStorage.check_migration_needed(path):
+            LocalStorage.perform_migration(path)
+        with open_storage(path, "w") as storage:
             execute_workflow(ert_config, storage, args.name)
         return
 
     status_queue: queue.SimpleQueue[StatusEvents] = queue.SimpleQueue()
+    using_local_queuesystem: bool = True
     try:
-        with ErtPluginContext():
+        with use_runtime_plugins(get_site_plugins()):
             model = create_model(
                 ert_config,
                 args,
                 status_queue,
             )
+            using_local_queuesystem = (
+                ert_config.queue_config.queue_system == QueueSystem.LOCAL
+            )
     except ValueError as e:
         raise ErtCliError(f"{args.mode} was not valid, failed with: {e}") from e
 
@@ -118,17 +123,17 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
             f"and DESIGN_MATRIX ({model.active_realizations.count(True)})"
         )
 
-    if args.port_range is None and model.queue_system == QueueSystem.LOCAL:
+    if args.port_range is None and using_local_queuesystem:
         # This is within the range for ephemeral ports as defined by
         # most unix flavors https://en.wikipedia.org/wiki/Ephemeral_port
         args.port_range = range(49152, 51819)
 
-    use_ipc_protocol = model.queue_system == QueueSystem.LOCAL
     evaluator_server_config = EvaluatorServerConfig(
         port_range=None
         if args.port_range is None
         else (min(args.port_range), max(args.port_range) + 1),
-        use_ipc_protocol=use_ipc_protocol,
+        use_ipc_protocol=using_local_queuesystem,
+        prioritize_private_ip_address=ert_config.prioritize_private_ip_address,
     )
 
     if model.check_if_runpath_exists():

ert/cli/monitor.py

@@ -9,6 +9,7 @@ from typing import TextIO
 import humanize
 from tqdm import tqdm
 
+from _ert.events import EnsembleEvaluationWarning
 from ert.ensemble_evaluator import (
     EndEvent,
     EnsembleSnapshot,
@@ -19,6 +20,7 @@ from ert.ensemble_evaluator import identifiers as ids
 from ert.ensemble_evaluator.state import (
     COLOR_FAILED,
     COLOR_FINISHED,
+    COLOR_WARNING,
     FORWARD_MODEL_STATE_FAILURE,
     REAL_STATE_TO_COLOR,
 )
@@ -96,6 +98,11 @@ class Monitor:
                     | RunModelErrorEvent() as event
                 ):
                     event.write_as_csv(output_path)
+                case EnsembleEvaluationWarning(warning_message=msg):
+                    print(
+                        self._colorize(msg, color=COLOR_WARNING),
+                        file=self._out,
+                    )
 
     def _print_step_errors(self) -> None:
         failed_steps: dict[str | None, int] = {}