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

_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/__main__.py

@@ -80,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 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,
@@ -567,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(

ert/analysis/_es_update.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import functools
 import logging
-import re
 import time
 import warnings
 from collections.abc import Callable, Iterable, Sequence
@@ -442,12 +441,6 @@ 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],
@@ -456,18 +449,12 @@ def smoother_update(
                 file: TextIO | None = None,
                 line: str | None = None,
             ) -> None:
-                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
-                    )
+                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/cli/main.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 from __future__ import annotations
 
 import contextlib
@@ -7,6 +6,7 @@ import os
 import queue
 import sys
 from collections import Counter
+from pathlib import Path
 from typing import TextIO
 
 from _ert.threading import ErtThread
@@ -27,7 +27,7 @@ from ert.namespace import Namespace
 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
 
 
@@ -88,7 +88,10 @@ 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
 
@@ -130,6 +133,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
         if args.port_range is None
         else (min(args.port_range), max(args.port_range) + 1),
         use_ipc_protocol=using_local_queuesystem,
+        prioritize_private_ip_address=ert_config.prioritize_private_ip_address,
     )
 
     if model.check_if_runpath_exists():

ert/config/__init__.py

@@ -11,8 +11,8 @@ from .ensemble_config import EnsembleConfig
 from .ert_config import ErtConfig, forward_model_step_from_config_contents
 from .ert_plugin import ErtPlugin
 from .ert_script import ErtScript
+from .everest_control import EverestControl, SamplerConfig
 from .everest_response import EverestConstraintsConfig, EverestObjectivesConfig
-from .ext_param_config import ExtParamConfig, SamplerConfig
 from .external_ert_script import ExternalErtScript
 from .field import Field, field_transform
 from .forward_model_step import (
@@ -31,7 +31,7 @@ from .gen_kw_config import DataSource, GenKwConfig, PriorDict
 from .known_response_types import KnownResponseTypes
 from .lint_file import lint_file
 from .model_config import ModelConfig
-from .parameter_config import ParameterCardinality, ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterCardinality, ParameterConfig
 from .parsing import (
     ConfigValidationError,
     ConfigWarning,
@@ -90,9 +90,9 @@ __all__ = [
     "ErtScript",
     "ErtScriptWorkflow",
     "EverestConstraintsConfig",
+    "EverestControl",
     "EverestObjectivesConfig",
     "ExecutableWorkflow",
-    "ExtParamConfig",
     "ExternalErtScript",
     "Field",
     "ForwardModelStep",
@@ -119,7 +119,6 @@ __all__ = [
     "OutlierSettings",
     "ParameterCardinality",
     "ParameterConfig",
-    "ParameterMetadata",
     "PostExperimentFixtures",
     "PostSimulationFixtures",
     "PostUpdateFixtures",

ert/config/_create_observation_dataframes.py

@@ -18,6 +18,7 @@ from ._observations import (
     Observation,
     ObservationDate,
     ObservationError,
+    RFTObservation,
     SummaryObservation,
 )
 from .gen_data_config import GenDataConfig
@@ -28,6 +29,7 @@ from .parsing import (
     ObservationConfigError,
 )
 from .refcase import Refcase
+from .rft_config import RFTConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -41,6 +43,7 @@ def create_observation_dataframes(
     observations: Sequence[Observation],
     refcase: Refcase | None,
     gen_data_config: GenDataConfig | None,
+    rft_config: RFTConfig | None,
     time_map: list[datetime] | None,
     history: HistorySource,
 ) -> dict[str, pl.DataFrame]:
@@ -56,7 +59,6 @@ def create_observation_dataframes(
     config_errors: list[ErrorInfo] = []
     grouped: dict[str, list[pl.DataFrame]] = defaultdict(list)
     for obs in observations:
-        obs_name = obs.name
         try:
             match obs:
                 case HistoryObservation():
@@ -64,7 +66,7 @@ def create_observation_dataframes(
                         _handle_history_observation(
                             refcase,
                             obs,
-                            obs_name,
+                            obs.name,
                             history,
                             time_len,
                         )
@@ -73,7 +75,7 @@ def create_observation_dataframes(
                     grouped["summary"].append(
                         _handle_summary_observation(
                             obs,
-                            obs_name,
+                            obs.name,
                             obs_time_list,
                             bool(refcase),
                         )
@@ -83,11 +85,18 @@ def create_observation_dataframes(
                         _handle_general_observation(
                             gen_data_config,
                             obs,
-                            obs_name,
+                            obs.name,
                             obs_time_list,
                             bool(refcase),
                         )
                     )
+                case RFTObservation():
+                    if rft_config is None:
+                        raise TypeError(
+                            "create_observation_dataframes requires "
+                            "rft_config is not None when using RFTObservation"
+                        )
+                    grouped["rft"].append(_handle_rft_observation(rft_config, obs))
                 case default:
                     assert_never(default)
         except ObservationConfigError as err:
@@ -460,10 +469,8 @@ def _handle_general_observation(
         stds = file_values[1::2]
 
     else:
-        assert (
-            general_observation.value is not None
-            and general_observation.error is not None
-        )
+        assert general_observation.value is not None
+        assert general_observation.error is not None
         values = np.array([general_observation.value])
         stds = np.array([general_observation.error])
 
@@ -509,3 +516,45 @@ def _handle_general_observation(
             "std": pl.Series(stds, dtype=pl.Float32),
         }
     )
+
+
+def _handle_rft_observation(
+    rft_config: RFTConfig,
+    rft_observation: RFTObservation,
+) -> pl.DataFrame:
+    location = (rft_observation.east, rft_observation.north, rft_observation.tvd)
+    if location not in rft_config.locations:
+        rft_config.locations.append(location)
+
+    data_to_read = rft_config.data_to_read
+    if rft_observation.well not in data_to_read:
+        rft_config.data_to_read[rft_observation.well] = {}
+
+    well_dict = data_to_read[rft_observation.well]
+    if rft_observation.date not in well_dict:
+        well_dict[rft_observation.date] = []
+
+    property_list = well_dict[rft_observation.date]
+    if rft_observation.property not in property_list:
+        property_list.append(rft_observation.property)
+
+    if rft_observation.error <= 0.0:
+        raise ObservationConfigError.with_context(
+            "Observation uncertainty must be strictly > 0", rft_observation.well
+        )
+
+    return pl.DataFrame(
+        {
+            "response_key": (
+                f"{rft_observation.well}:"
+                f"{rft_observation.date}:"
+                f"{rft_observation.property}"
+            ),
+            "observation_key": rft_observation.name,
+            "east": pl.Series([location[0]], dtype=pl.Float32),
+            "north": pl.Series([location[1]], dtype=pl.Float32),
+            "tvd": pl.Series([location[2]], dtype=pl.Float32),
+            "observations": pl.Series([rft_observation.value], dtype=pl.Float32),
+            "std": pl.Series([rft_observation.error], dtype=pl.Float32),
+        }
+    )

ert/config/_get_num_cpu.py

@@ -156,7 +156,7 @@ class _Parser:
     def next_line(self) -> Iterator[str]: ...
 
     @overload
-    def next_line(self, __default: T) -> Iterator[str] | T: ...
+    def next_line(self, __default: T, /) -> Iterator[str] | T: ...
 
     def next_line(self, *args: T) -> Iterator[str] | T:
         self.line_number += 1

ert/config/_observations.py

@@ -214,12 +214,88 @@ class GeneralObservation(ObservationDate, _GeneralObservation):
         return output
 
 
-Observation = HistoryObservation | SummaryObservation | GeneralObservation
+@dataclass
+class RFTObservation:
+    name: str
+    well: str
+    date: str
+    property: str
+    value: float
+    error: float
+    north: float
+    east: float
+    tvd: float
+
+    @classmethod
+    def from_obs_dict(cls, directory: str, observation_dict: ObservationDict) -> Self:
+        well = None
+        observed_property = None
+        observed_value = None
+        error = None
+        date = None
+        north = None
+        east = None
+        tvd = None
+        for key, value in observation_dict.items():
+            match key:
+                case "type" | "name":
+                    pass
+                case "WELL":
+                    well = value
+                case "PROPERTY":
+                    observed_property = value
+                case "VALUE":
+                    observed_value = validate_float(value, key)
+                case "ERROR":
+                    error = validate_float(value, key)
+                case "DATE":
+                    date = value
+                case "NORTH":
+                    north = validate_float(value, key)
+                case "EAST":
+                    east = validate_float(value, key)
+                case "TVD":
+                    tvd = validate_float(value, key)
+                case _:
+                    raise _unknown_key_error(str(key), observation_dict["name"])
+        if well is None:
+            raise _missing_value_error(observation_dict["name"], "WELL")
+        if observed_value is None:
+            raise _missing_value_error(observation_dict["name"], "VALUE")
+        if observed_property is None:
+            raise _missing_value_error(observation_dict["name"], "PROPERTY")
+        if error is None:
+            raise _missing_value_error(observation_dict["name"], "ERROR")
+        if date is None:
+            raise _missing_value_error(observation_dict["name"], "DATE")
+        if north is None:
+            raise _missing_value_error(observation_dict["name"], "NORTH")
+        if east is None:
+            raise _missing_value_error(observation_dict["name"], "EAST")
+        if tvd is None:
+            raise _missing_value_error(observation_dict["name"], "TVD")
+        return cls(
+            observation_dict["name"],
+            well,
+            date,
+            observed_property,
+            observed_value,
+            error,
+            north,
+            east,
+            tvd,
+        )
+
+
+Observation = (
+    HistoryObservation | SummaryObservation | GeneralObservation | RFTObservation
+)
 
 _TYPE_TO_CLASS: dict[ObservationType, type[Observation]] = {
     ObservationType.HISTORY: HistoryObservation,
     ObservationType.SUMMARY: SummaryObservation,
     ObservationType.GENERAL: GeneralObservation,
+    ObservationType.RFT: RFTObservation,
 }
 
 

ert/config/distribution.py

@@ -17,7 +17,7 @@ class TransSettingsValidation(BaseModel):
     model_config = {"extra": "forbid"}
 
     @classmethod
-    def create(cls: type[T], *args: Any, **kwargs: Any) -> T:
+    def create(cls, *args: Any, **kwargs: Any) -> Self:
         return cls(*args, **kwargs)
 
     @classmethod

ert/config/ensemble_config.py

@@ -7,7 +7,7 @@ from typing import Self
 
 from pydantic import BaseModel, Field, model_validator
 
-from .ext_param_config import ExtParamConfig
+from .everest_control import EverestControl
 from .field import Field as FieldConfig
 from .gen_kw_config import GenKwConfig
 from .known_response_types import KNOWN_ERT_RESPONSE_TYPES, KnownErtResponseTypes
@@ -22,7 +22,7 @@ logger = logging.getLogger(__name__)
 class EnsembleConfig(BaseModel):
     response_configs: dict[str, KnownErtResponseTypes] = Field(default_factory=dict)
     parameter_configs: dict[
-        str, GenKwConfig | FieldConfig | SurfaceConfig | ExtParamConfig
+        str, GenKwConfig | FieldConfig | SurfaceConfig | EverestControl
     ] = Field(default_factory=dict)
 
     @model_validator(mode="after")
@@ -132,7 +132,7 @@ class EnsembleConfig(BaseModel):
                 response_configs.append(instance)
 
         return cls(
-            response_configs={response.name: response for response in response_configs},
+            response_configs={response.type: response for response in response_configs},
             parameter_configs={
                 parameter.name: parameter for parameter in parameter_configs
             },

ert/config/ert_config.py

@@ -25,6 +25,7 @@ from ._design_matrix_validator import DesignMatrixValidator
 from ._observations import (
     HistoryObservation,
     Observation,
+    RFTObservation,
     SummaryObservation,
     make_observations,
 )
@@ -62,6 +63,7 @@ from .parsing import (
 from .parsing.observations_parser import ObservationDict
 from .queue_config import KnownQueueOptions, QueueConfig
 from .refcase import Refcase
+from .rft_config import RFTConfig
 from .workflow import Workflow
 from .workflow_fixtures import fixtures_per_hook
 from .workflow_job import (
@@ -686,14 +688,6 @@ def log_observation_keys(
         if key not in {"name", "type"}
     )
 
-    if "HISTORY_OBSERVATION" in observation_type_counts:
-        msg = (
-            "HISTORY_OBSERVATION is deprecated and will be removed. "
-            "Please use SUMMARY_OBSERVATION instead."
-        )
-        ConfigWarning.warn(msg)
-        logger.warning(msg)
-
     logger.info(
         f"Count of observation types:\n\t{dict(observation_type_counts)}\n"
         f"Count of observation keywords:\n\t{dict(observation_keyword_counts)}"
@@ -715,6 +709,7 @@ class ErtConfig(BaseModel):
     QUEUE_OPTIONS: ClassVar[KnownQueueOptions | None] = None
     RESERVED_KEYWORDS: ClassVar[list[str]] = RESERVED_KEYWORDS
     ENV_VARS: ClassVar[dict[str, str]] = {}
+    PRIORITIZE_PRIVATE_IP_ADDRESS: ClassVar[bool] = False
 
     substitutions: dict[str, str] = Field(default_factory=dict)
     ensemble_config: EnsembleConfig = Field(default_factory=EnsembleConfig)
@@ -729,6 +724,7 @@ class ErtConfig(BaseModel):
         default_factory=lambda: defaultdict(lambda: cast(list[Workflow], []))
     )
     runpath_file: Path = Path(DEFAULT_RUNPATH_FILE)
+    prioritize_private_ip_address: bool = False
 
     ert_templates: list[tuple[str, str]] = Field(default_factory=list)
 
@@ -745,6 +741,18 @@ class ErtConfig(BaseModel):
     @property
     def observations(self) -> dict[str, pl.DataFrame]:
         if self._observations is None:
+            has_rft_observations = any(
+                isinstance(o, RFTObservation) for o in self.observation_declarations
+            )
+            if (
+                has_rft_observations
+                and "rft" not in self.ensemble_config.response_configs
+            ):
+                self.ensemble_config.response_configs["rft"] = RFTConfig(
+                    input_files=[self.runpath_config.eclbase_format_string],
+                    data_to_read={},
+                    locations=[],
+                )
             computed = create_observation_dataframes(
                 self.observation_declarations,
                 self.refcase,
@@ -752,6 +760,10 @@ class ErtConfig(BaseModel):
                     GenDataConfig | None,
                     self.ensemble_config.response_configs.get("gen_data", None),
                 ),
+                cast(
+                    RFTConfig | None,
+                    self.ensemble_config.response_configs.get("rft", None),
+                ),
                 self.time_map,
                 self.history_source,
             )
@@ -848,6 +860,9 @@ class ErtConfig(BaseModel):
             )
             ENV_VARS = dict(runtime_plugins.environment_variables)
             QUEUE_OPTIONS = runtime_plugins.queue_options
+            PRIORITIZE_PRIVATE_IP_ADDRESS = (
+                runtime_plugins.prioritize_private_ip_address
+            )
 
         ErtConfigWithPlugins.model_rebuild()
         assert issubclass(ErtConfigWithPlugins, ErtConfig)
@@ -1100,6 +1115,19 @@ class ErtConfig(BaseModel):
             user_configured_.add(key)
             env_vars[key] = substituter.substitute(val)
 
+        prioritize_private_ip_address: bool = cls.PRIORITIZE_PRIVATE_IP_ADDRESS
+        if ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS in config_dict:
+            user_prioritize_private_ip_address = bool(
+                config_dict[ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS]
+            )
+            if prioritize_private_ip_address != user_prioritize_private_ip_address:
+                logger.warning(
+                    "PRIORITIZE_PRIVATE_IP_ADDRESS was overwritten by user: "
+                    f"{prioritize_private_ip_address} -> "
+                    f"{user_prioritize_private_ip_address}"
+                )
+                prioritize_private_ip_address = user_prioritize_private_ip_address
+
         try:
             refcase = Refcase.from_config_dict(config_dict)
             cls_config = cls(
@@ -1126,11 +1154,21 @@ class ErtConfig(BaseModel):
                 time_map=time_map,
                 history_source=history_source,
                 refcase=refcase,
+                prioritize_private_ip_address=prioritize_private_ip_address,
             )
 
             # The observations are created here because create_observation_dataframes
             # will perform additonal validation which needs the context in
             # obs_configs which is stripped by pydantic
+            has_rft_observations = any(
+                isinstance(o, RFTObservation) for o in obs_configs
+            )
+            if has_rft_observations and "rft" not in ensemble_config.response_configs:
+                ensemble_config.response_configs["rft"] = RFTConfig(
+                    input_files=[eclbase],
+                    data_to_read={},
+                    locations=[],
+                )
             cls_config._observations = create_observation_dataframes(
                 obs_configs,
                 refcase,
@@ -1138,6 +1176,10 @@ class ErtConfig(BaseModel):
                     GenDataConfig | None,
                     ensemble_config.response_configs.get("gen_data", None),
                 ),
+                cast(
+                    RFTConfig | None,
+                    ensemble_config.response_configs.get("rft", None),
+                ),
                 time_map,
                 history_source,
             )

ert/config/{ext_param_config.py → everest_control.py}

@@ -17,7 +17,7 @@ from ropt.workflow import find_sampler_plugin
 
 from ert.substitutions import substitute_runpath_name
 
-from .parameter_config import ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -106,7 +106,7 @@ class SamplerConfig(BaseModel):
             # from "everest" here as per old behavior.
             # Can consider logging this as if from ERT,
             # which is valid if we store SamplerConfig as part of
-            # ExtParam configs.
+            # EverestControl configs.
             logging.getLogger("everest").warning(message)
 
         # Update the default for backends that are not scipy:
@@ -142,22 +142,14 @@ class SamplerConfig(BaseModel):
         return self
 
 
-class ExtParamConfig(ParameterConfig):
-    """Create an ExtParamConfig for @key with the given @input_keys
+class EverestControl(ParameterConfig):
+    """Create an EverestControl for @key with the given @input_keys
 
     @input_keys can be either a list of keys as strings or a dict with
     keys as strings and a list of suffixes for each key.
     If a list of strings is given, the order is preserved.
     """
 
-    @property
-    def parameter_keys(self) -> list[str]:
-        return self.input_keys
-
-    @property
-    def metadata(self) -> list[ParameterMetadata]:
-        return []
-
     type: Literal["everest_parameters"] = "everest_parameters"
     input_keys: list[str] = field(default_factory=list)
     forward_init: bool = False
@@ -179,6 +171,10 @@ class ExtParamConfig(ParameterConfig):
     # "dotdash" notation is removed for everest controls via everest config.
     input_keys_dotdash: list[str] = field(default_factory=list)
 
+    @property
+    def parameter_keys(self) -> list[str]:
+        return self.input_keys
+
     def read_from_runpath(
         self, run_path: Path, real_nr: int, iteration: int
     ) -> xr.Dataset: