ert 18.0.8__py3-none-any.whl → 19.0.0__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/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,19 +29,21 @@ from .parsing import (
     ObservationConfigError,
 )
 from .refcase import Refcase
+from .rft_config import RFTConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
 
 
 DEFAULT_TIME_DELTA = timedelta(seconds=30)
-DEFAULT_LOCATION_RANGE_M = 3000
+DEFAULT_LOCALIZATION_RADIUS = 3000
 
 
 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:
@@ -196,6 +205,9 @@ def _handle_history_observation(
             "time": dates_series,
             "observations": pl.Series(values, dtype=pl.Float32),
             "std": pl.Series(std_dev, dtype=pl.Float32),
+            "east": pl.Series([None] * len(values), dtype=pl.Float32),
+            "north": pl.Series([None] * len(values), dtype=pl.Float32),
+            "radius": pl.Series([None] * len(values), dtype=pl.Float32),
         }
     )
 
@@ -288,40 +300,7 @@ def _get_restart(
 
 
 def _has_localization(summary_dict: SummaryObservation) -> bool:
-    return any(
-        [
-            summary_dict.location_x is not None,
-            summary_dict.location_y is not None,
-            summary_dict.location_range is not None,
-        ]
-    )
-
-
-def _validate_localization_values(summary_dict: SummaryObservation) -> None:
-    """The user must provide LOCATION_X and LOCATION_Y to use localization, while
-    unprovided LOCATION_RANGE should default to some value.
-
-    This method assumes the summary dict contains at least one LOCATION key.
-    """
-    if summary_dict.location_x is None or summary_dict.location_y is None:
-        loc_values = {
-            "LOCATION_X": summary_dict.location_x,
-            "LOCATION_Y": summary_dict.location_y,
-            "LOCATION_RANGE": summary_dict.location_range,
-        }
-        provided_loc_values = {k: v for k, v in loc_values.items() if v is not None}
-
-        provided_loc_values_string = ", ".join(
-            key.upper() for key in provided_loc_values
-        )
-        raise ObservationConfigError.with_context(
-            f"Localization for observation {summary_dict.name} is misconfigured.\n"
-            f"Only {provided_loc_values_string} were provided. To enable "
-            f"localization for an observation, ensure that both LOCATION_X and "
-            f"LOCATION_Y are defined - or remove LOCATION keywords to disable "
-            f"localization.",
-            summary_dict,
-        )
+    return summary_dict.east is not None and summary_dict.north is not None
 
 
 def _handle_summary_observation(
@@ -361,23 +340,24 @@ def _handle_summary_observation(
             "Observation uncertainty must be strictly > 0", summary_key
         ) from None
 
-    data_dict = {
-        "response_key": [summary_key],
-        "observation_key": [obs_key],
-        "time": pl.Series([date]).dt.cast_time_unit("ms"),
-        "observations": pl.Series([value], dtype=pl.Float32),
-        "std": pl.Series([std_dev], dtype=pl.Float32),
-    }
-
-    if _has_localization(summary_dict):
-        _validate_localization_values(summary_dict)
-        data_dict["location_x"] = summary_dict.location_x
-        data_dict["location_y"] = summary_dict.location_y
-        data_dict["location_range"] = (
-            summary_dict.location_range or DEFAULT_LOCATION_RANGE_M
-        )
+    localization_radius = (
+        summary_dict.radius or DEFAULT_LOCALIZATION_RADIUS
+        if _has_localization(summary_dict)
+        else None
+    )
 
-    return pl.DataFrame(data_dict)
+    return pl.DataFrame(
+        {
+            "response_key": [summary_key],
+            "observation_key": [obs_key],
+            "time": pl.Series([date]).dt.cast_time_unit("ms"),
+            "observations": pl.Series([value], dtype=pl.Float32),
+            "std": pl.Series([std_dev], dtype=pl.Float32),
+            "east": pl.Series([summary_dict.east], dtype=pl.Float32),
+            "north": pl.Series([summary_dict.north], dtype=pl.Float32),
+            "radius": pl.Series([localization_radius], dtype=pl.Float32),
+        }
+    )
 
 
 def _handle_general_observation(
@@ -460,10 +440,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])
 
@@ -507,5 +485,53 @@ def _handle_general_observation(
             "index": pl.Series(indices, dtype=pl.UInt16),
             "observations": pl.Series(values, dtype=pl.Float32),
             "std": pl.Series(stds, dtype=pl.Float32),
+            # Location attributes will always be None for general observations, but are
+            # necessary to concatenate with other observation dataframes.
+            "east": pl.Series([None] * len(values), dtype=pl.Float32),
+            "north": pl.Series([None] * len(values), dtype=pl.Float32),
+            "radius": pl.Series([None] * len(values), 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),
+            "radius": pl.Series([None], 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

@@ -1,5 +1,4 @@
 import os
-from collections import Counter
 from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import StrEnum
@@ -90,9 +89,9 @@ class _SummaryValues:
     name: str
     value: float
     key: str  #: The :term:`summary key` in the summary response
-    location_x: float | None = None
-    location_y: float | None = None
-    location_range: float | None = None
+    east: float | None = None
+    north: float | None = None
+    radius: float | None = None
 
 
 @dataclass
@@ -104,7 +103,7 @@ class SummaryObservation(ObservationDate, _SummaryValues, ObservationError):
 
         date_dict: ObservationDate = ObservationDate()
         float_values: dict[str, float] = {"ERROR_MIN": 0.1}
-        localization_values: dict[str, float] = {}
+        localization_values: dict[str, float | None] = {}
         for key, value in observation_dict.items():
             match key:
                 case "type" | "name":
@@ -125,12 +124,15 @@ class SummaryObservation(ObservationDate, _SummaryValues, ObservationError):
                     summary_key = value
                 case "DATE":
                     date_dict.date = value
-                case "LOCATION_X":
-                    localization_values["x"] = validate_float(value, key)
-                case "LOCATION_Y":
-                    localization_values["y"] = validate_float(value, key)
-                case "LOCATION_RANGE":
-                    localization_values["range"] = validate_float(value, key)
+                case "LOCALIZATION":
+                    validate_localization(value, observation_dict["name"])
+                    localization_values["east"] = validate_float(value["EAST"], key)
+                    localization_values["north"] = validate_float(value["NORTH"], key)
+                    localization_values["radius"] = (
+                        validate_float(value["RADIUS"], key)
+                        if "RADIUS" in value
+                        else None
+                    )
                 case _:
                     raise _unknown_key_error(str(key), observation_dict["name"])
         if "VALUE" not in float_values:
@@ -147,9 +149,9 @@ class SummaryObservation(ObservationDate, _SummaryValues, ObservationError):
             error_min=float_values["ERROR_MIN"],
             key=summary_key,
             value=float_values["VALUE"],
-            location_x=localization_values.get("x"),
-            location_y=localization_values.get("y"),
-            location_range=localization_values.get("range"),
+            east=localization_values.get("east"),
+            north=localization_values.get("north"),
+            radius=localization_values.get("radius"),
             **date_dict.__dict__,
         )
 
@@ -214,12 +216,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,
 }
 
 
@@ -248,25 +326,9 @@ def make_observations(
     if error_list:
         raise ObservationConfigError.from_collected(error_list)
 
-    _validate_unique_names(result)
     return result
 
 
-def _validate_unique_names(
-    observations: Sequence[Observation],
-) -> None:
-    names_counter = Counter(d.name for d in observations)
-    duplicate_names = [n for n, c in names_counter.items() if c > 1]
-    errors = [
-        ErrorInfo(
-            f"Duplicate observation name {n}",
-        ).set_context(n)
-        for n in duplicate_names
-    ]
-    if errors:
-        raise ObservationConfigError.from_collected(errors)
-
-
 def _validate_segment_dict(name_token: str, inp: dict[str, Any]) -> Segment:
     start = None
     stop = None
@@ -339,6 +401,19 @@ def validate_positive_float(val: str, key: str) -> float:
     return v
 
 
+def validate_localization(val: dict[str, Any], obs_name: str) -> None:
+    errors = []
+    if "EAST" not in val:
+        errors.append(_missing_value_error(f"LOCALIZATION for {obs_name}", "EAST"))
+    if "NORTH" not in val:
+        errors.append(_missing_value_error(f"LOCALIZATION for {obs_name}", "NORTH"))
+    for key in val:
+        if key not in {"EAST", "NORTH", "RADIUS"}:
+            errors.append(_unknown_key_error(key, f"LOCALIZATION for {obs_name}"))
+    if errors:
+        raise ObservationConfigError.from_collected(errors)
+
+
 def validate_positive_int(val: str, key: str) -> int:
     try:
         v = int(val)

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
             },