ert 17.1.9__py3-none-any.whl → 18.0.0__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/__main__.py

@@ -35,8 +35,9 @@ from ert.mode_definitions import (
 )
 from ert.namespace import Namespace
 from ert.plugins import ErtRuntimePlugins, get_site_plugins, setup_site_logging
-from ert.run_models.multiple_data_assimilation import MultipleDataAssimilation
-from ert.services import StorageService, WebvizErt
+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, ErtStoragePermissionError
 from ert.trace import trace, tracer
@@ -53,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()
@@ -80,7 +81,7 @@ def run_webviz_ert(args: Namespace, _: ErtRuntimePlugins | None = None) -> None:
     kwargs["ert_config"] = os.path.basename(args.config)
     kwargs["project"] = os.path.abspath(ens_path)
     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(
                 """
@@ -501,7 +502,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.",
@@ -598,7 +599,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,

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(

ert/cli/main.py

@@ -93,6 +93,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
         return
 
     status_queue: queue.SimpleQueue[StatusEvents] = queue.SimpleQueue()
+    using_local_queuesystem: bool = True
     try:
         with use_runtime_plugins(get_site_plugins()):
             model = create_model(
@@ -100,6 +101,9 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
                 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
 
@@ -116,17 +120,16 @@ 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,
     )
 
     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] = {}

ert/config/__init__.py

@@ -11,9 +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_constraints_config import EverestConstraintsConfig
-from .everest_objective_config import EverestObjectivesConfig
-from .ext_param_config import ExtParamConfig
+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 (
@@ -23,9 +22,13 @@ from .forward_model_step import (
     ForwardModelStepPlugin,
     ForwardModelStepValidationError,
     ForwardModelStepWarning,
+    SiteInstalledForwardModelStep,
+    SiteOrUserForwardModelStep,
+    UserInstalledForwardModelStep,
 )
 from .gen_data_config import GenDataConfig
 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
@@ -45,6 +48,7 @@ from .queue_config import (
     QueueConfig,
 )
 from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
+from .rft_config import RFTConfig
 from .summary_config import SummaryConfig
 from .surface_config import SurfaceConfig
 from .workflow import Workflow
@@ -105,6 +109,7 @@ __all__ = [
     "InversionTypeES",
     "KnownQueueOptions",
     "KnownQueueOptionsAdapter",
+    "KnownResponseTypes",
     "LegacyWorkflowConfigs",
     "LocalQueueOptions",
     "ModelConfig",
@@ -125,10 +130,15 @@ __all__ = [
     "PriorDict",
     "QueueConfig",
     "QueueSystem",
+    "RFTConfig",
     "ResponseConfig",
     "ResponseMetadata",
+    "SamplerConfig",
+    "SiteInstalledForwardModelStep",
+    "SiteOrUserForwardModelStep",
     "SummaryConfig",
     "SurfaceConfig",
+    "UserInstalledForwardModelStep",
     "WarningInfo",
     "Workflow",
     "WorkflowConfigs",

ert/config/_create_observation_dataframes.py

@@ -34,6 +34,7 @@ if TYPE_CHECKING:
 
 
 DEFAULT_TIME_DELTA = timedelta(seconds=30)
+DEFAULT_LOCATION_RANGE_M = 3000
 
 
 def create_observation_dataframes(
@@ -286,6 +287,43 @@ def _get_restart(
         ) from err
 
 
+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,
+        )
+
+
 def _handle_summary_observation(
     summary_dict: SummaryObservation,
     obs_key: str,
@@ -323,15 +361,23 @@ def _handle_summary_observation(
             "Observation uncertainty must be strictly > 0", summary_key
         ) from None
 
-    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),
-        }
-    )
+    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
+        )
+
+    return pl.DataFrame(data_dict)
 
 
 def _handle_general_observation(
@@ -439,9 +485,11 @@ def _handle_general_observation(
         raise ObservationConfigError.with_context(
             f"Values ({values}), error ({stds}) and "
             f"index list ({indices}) must be of equal length",
-            general_observation.obs_file
-            if general_observation.obs_file is not None
-            else "",
+            (
+                general_observation.obs_file
+                if general_observation.obs_file is not None
+                else ""
+            ),
         )
 
     if np.any(stds <= 0):

ert/config/_observations.py

@@ -90,10 +90,13 @@ 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
 
 
 @dataclass
-class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
+class SummaryObservation(ObservationDate, _SummaryValues, ObservationError):
     @classmethod
     def from_obs_dict(cls, directory: str, observation_dict: ObservationDict) -> Self:
         error_mode = ErrorModes.ABS
@@ -101,6 +104,7 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
 
         date_dict: ObservationDate = ObservationDate()
         float_values: dict[str, float] = {"ERROR_MIN": 0.1}
+        localization_values: dict[str, float] = {}
         for key, value in observation_dict.items():
             match key:
                 case "type" | "name":
@@ -121,6 +125,12 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
                     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 _:
                     raise _unknown_key_error(str(key), observation_dict["name"])
         if "VALUE" not in float_values:
@@ -137,6 +147,9 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
             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"),
             **date_dict.__dict__,
         )
 

ert/config/_read_summary.py

@@ -12,6 +12,7 @@ import warnings
 from collections.abc import Callable, Sequence
 from datetime import datetime, timedelta
 from enum import Enum, auto
+from functools import lru_cache
 
 import numpy as np
 import numpy.typing as npt
@@ -83,29 +84,30 @@ class DateUnit(Enum):
         raise InvalidResponseFile(f"Unknown date unit {val}")
 
 
+@lru_cache
 def _fetch_keys_to_matcher(fetch_keys: Sequence[str]) -> Callable[[str], bool]:
     """
     Transform the list of keys (with * used as repeated wildcard) into
     a matcher.
 
-    >>> match = _fetch_keys_to_matcher([""])
+    >>> match = _fetch_keys_to_matcher(("",))
     >>> match("FOPR")
     False
 
-    >>> match = _fetch_keys_to_matcher(["*"])
+    >>> match = _fetch_keys_to_matcher(("*",))
     >>> match("FOPR"), match("FO*")
     (True, True)
 
 
-    >>> match = _fetch_keys_to_matcher(["F*PR"])
+    >>> match = _fetch_keys_to_matcher(("F*PR",))
     >>> match("WOPR"), match("FOPR"), match("FGPR"), match("SOIL")
     (False, True, True, False)
 
-    >>> match = _fetch_keys_to_matcher(["WGOR:*"])
+    >>> match = _fetch_keys_to_matcher(("WGOR:*",))
     >>> match("FOPR"), match("WGOR:OP1"), match("WGOR:OP2"), match("WGOR")
     (False, True, True, False)
 
-    >>> match = _fetch_keys_to_matcher(["FOPR", "FGPR"])
+    >>> match = _fetch_keys_to_matcher(("FOPR", "FGPR"))
     >>> match("FOPR"), match("FGPR"), match("WGOR:OP2"), match("WGOR")
     (True, True, False, False)
     """
@@ -138,7 +140,7 @@ def _read_spec(
     date_index = None
     date_unit_str = None
 
-    should_load_key = _fetch_keys_to_matcher(fetch_keys)
+    should_load_key = _fetch_keys_to_matcher(tuple(fetch_keys))
 
     for i, kw in enumerate(keywords):
         try:

ert/config/ensemble_config.py

@@ -9,26 +9,18 @@ from pydantic import BaseModel, Field, model_validator
 
 from .ext_param_config import ExtParamConfig
 from .field import Field as FieldConfig
-from .gen_data_config import GenDataConfig
 from .gen_kw_config import GenKwConfig
+from .known_response_types import KNOWN_ERT_RESPONSE_TYPES, KnownErtResponseTypes
 from .parameter_config import ParameterConfig
 from .parsing import ConfigDict, ConfigKeys, ConfigValidationError
 from .response_config import ResponseConfig
-from .summary_config import SummaryConfig
 from .surface_config import SurfaceConfig
 
-KnownResponseTypes = SummaryConfig | GenDataConfig
-
-_KNOWN_RESPONSE_TYPES = (
-    SummaryConfig,
-    GenDataConfig,
-)
-
 logger = logging.getLogger(__name__)
 
 
 class EnsembleConfig(BaseModel):
-    response_configs: dict[str, KnownResponseTypes] = Field(default_factory=dict)
+    response_configs: dict[str, KnownErtResponseTypes] = Field(default_factory=dict)
     parameter_configs: dict[
         str, GenKwConfig | FieldConfig | SurfaceConfig | ExtParamConfig
     ] = Field(default_factory=dict)
@@ -131,9 +123,9 @@ class EnsembleConfig(BaseModel):
             + [make_field(f) for f in field_list]
         )
         EnsembleConfig._check_for_duplicate_gen_kw_param_names(gen_kw_cfgs)
-        response_configs: list[KnownResponseTypes] = []
+        response_configs: list[KnownErtResponseTypes] = []
 
-        for config_cls in _KNOWN_RESPONSE_TYPES:
+        for config_cls in KNOWN_ERT_RESPONSE_TYPES:
             instance = config_cls.from_config_dict(config_dict)
 
             if instance is not None and instance.keys:
@@ -151,13 +143,13 @@ class EnsembleConfig(BaseModel):
             return self.parameter_configs[key]
         elif key in self.response_configs:
             return self.response_configs[key]
-        elif _config := next(
+        elif config := next(
             (c for c in self.response_configs.values() if key in c.keys), None
         ):
             # Only hit by blockfs migration
             # returns the same config for one call per
             # response type. Is later deduped before saving to json
-            return _config
+            return config
         else:
             raise KeyError(f"The key:{key} is not in the ensemble configuration")
 

ert/config/ert_config.py

@@ -36,6 +36,9 @@ from .forward_model_step import (
     ForwardModelStepJSON,
     ForwardModelStepValidationError,
     ForwardModelStepWarning,
+    SiteInstalledForwardModelStep,
+    SiteOrUserForwardModelStep,
+    UserInstalledForwardModelStep,
 )
 from .gen_data_config import GenDataConfig
 from .gen_kw_config import DataSource, GenKwConfig
@@ -133,6 +136,7 @@ def create_forward_model_json(
         env_pr_fm_step = {}
 
     context_substitutions = Substitutions(context)
+    real_iter_substituter = context_substitutions.real_iter_substituter(iens, itr)
 
     class Substituter:
         def __init__(self, fm_step: ForwardModelStep) -> None:
@@ -146,7 +150,7 @@ def create_forward_model_json(
             )
             self.copy_private_args = Substitutions(
                 {
-                    key: context_substitutions.substitute_real_iter(val, iens, itr)
+                    key: real_iter_substituter.substitute(val)
                     for key, val in fm_step.private_args.items()
                 }
             )
@@ -163,7 +167,7 @@ def create_forward_model_json(
             string = self.copy_private_args.substitute(
                 string, self.substitution_context_hint, 1, warn_max_iter=False
             )
-            return context_substitutions.substitute_real_iter(string, iens, itr)
+            return real_iter_substituter.substitute(string)
 
         def filter_env_dict(self, env_dict: dict[str, str]) -> dict[str, str] | None:
             substituted_dict = {}
@@ -518,18 +522,16 @@ def workflows_from_dict(
 
 def installed_forward_model_steps_from_dict(
     config_dict: ConfigDict,
-) -> dict[str, ForwardModelStep]:
+) -> dict[str, UserInstalledForwardModelStep]:
     errors: list[ErrorInfo | ConfigValidationError] = []
-    fm_steps: dict[str, ForwardModelStep] = {}
+    fm_steps: dict[str, UserInstalledForwardModelStep] = {}
     for name, (fm_step_config_file, config_contents) in config_dict.get(
         ConfigKeys.INSTALL_JOB, []
     ):
         fm_step_config_file = path.abspath(fm_step_config_file)
         try:
             new_fm_step = forward_model_step_from_config_contents(
-                config_contents,
-                name=name,
-                config_file=fm_step_config_file,
+                config_contents, name=name, config_file=fm_step_config_file
             )
         except ConfigValidationError as e:
             errors.append(e)
@@ -692,6 +694,8 @@ def log_observation_keys(
 
 RESERVED_KEYWORDS = ["realization", "IENS", "ITER"]
 
+USER_CONFIG_SCHEMA = init_user_config_schema()
+
 
 class ErtConfig(BaseModel):
     DEFAULT_ENSPATH: ClassVar[str] = "storage"
@@ -720,7 +724,7 @@ class ErtConfig(BaseModel):
 
     ert_templates: list[tuple[str, str]] = Field(default_factory=list)
 
-    forward_model_steps: list[ForwardModelStep] = Field(default_factory=list)
+    forward_model_steps: list[SiteOrUserForwardModelStep] = Field(default_factory=list)
     runpath_config: ModelConfig = Field(default_factory=ModelConfig)
     user_config_file: str = "no_config"
     config_path: str = Field(init=False, default="")
@@ -826,7 +830,7 @@ class ErtConfig(BaseModel):
     def with_plugins(runtime_plugins: ErtRuntimePlugins) -> type[ErtConfig]:
         class ErtConfigWithPlugins(ErtConfig):
             PREINSTALLED_FORWARD_MODEL_STEPS: ClassVar[
-                Mapping[str, ForwardModelStep]
+                Mapping[str, SiteInstalledForwardModelStep]
             ] = runtime_plugins.installed_forward_model_steps
             PREINSTALLED_WORKFLOWS = dict(runtime_plugins.installed_workflow_jobs)
             ENV_PR_FM_STEP: ClassVar[dict[str, dict[str, Any]]] = (
@@ -1303,7 +1307,7 @@ class ErtConfig(BaseModel):
     @classmethod
     def _read_user_config_contents(cls, user_config: str, file_name: str) -> ConfigDict:
         return parse_contents(
-            user_config, file_name=file_name, schema=init_user_config_schema()
+            user_config, file_name=file_name, schema=USER_CONFIG_SCHEMA
         )
 
     @classmethod
@@ -1393,8 +1397,10 @@ def uppercase_subkeys_and_stringify_subvalues(
 
 
 def forward_model_step_from_config_contents(
-    config_contents: str, config_file: str, name: str | None = None
-) -> ForwardModelStep:
+    config_contents: str,
+    config_file: str,
+    name: str | None = None,
+) -> UserInstalledForwardModelStep:
     if name is None:
         name = os.path.basename(config_file)
 
@@ -1418,7 +1424,7 @@ def forward_model_step_from_config_contents(
     environment = {k: v for [k, v] in content_dict.get("ENV", [])}
     default_mapping = {k: v for [k, v] in content_dict.get("DEFAULT", [])}
 
-    return ForwardModelStep(
+    return UserInstalledForwardModelStep(
         name=name,
         executable=content_dict["EXECUTABLE"],
         stdin_file=content_dict.get("STDIN"),

ert/config/{everest_objective_config.py → everest_response.py}

@@ -11,13 +11,15 @@ from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetada
 from .responses_index import responses_index
 
 
-class EverestObjectivesConfig(ResponseConfig):
-    type: Literal["everest_objectives"] = "everest_objectives"
-    name: str = "everest_objectives"
+class EverestResponse(ResponseConfig):
+    """Base class for Everest response configurations."""
+
     has_finalized_keys: bool = True
-    weights: list[float | None]
     scales: list[float | None]
-    objective_types: list[Literal["mean", "stddev"]]
+
+    @property
+    def primary_key(self) -> list[str]:
+        return []
 
     @property
     def metadata(self) -> list[ResponseMetadata]:
@@ -52,7 +54,6 @@ class EverestObjectivesConfig(ResponseConfig):
             )
 
         errors = []
-
         run_path_ = Path(run_path)
         datasets_per_name = []
 
@@ -86,13 +87,23 @@ class EverestObjectivesConfig(ResponseConfig):
         combined = pl.concat(datasets_per_name)
         return combined
 
-    @property
-    def response_type(self) -> str:
-        return "everest_objectives"
 
-    @property
-    def primary_key(self) -> list[str]:
-        return []
+class EverestConstraintsConfig(EverestResponse):
+    type: Literal["everest_constraints"] = "everest_constraints"
+    name: str = "everest_constraints"
+    targets: list[float | None]
+    upper_bounds: list[float]
+    lower_bounds: list[float]
+
+
+responses_index.add_response_type(EverestConstraintsConfig)
+
+
+class EverestObjectivesConfig(EverestResponse):
+    type: Literal["everest_objectives"] = "everest_objectives"
+    name: str = "everest_objectives"
+    weights: list[float | None]
+    objective_types: list[Literal["mean", "stddev"]]
 
 
 responses_index.add_response_type(EverestObjectivesConfig)