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

everest/optimizer/opt_model_transforms.py

@@ -11,14 +11,11 @@ from ropt.transforms.base import (
     VariableTransform,
 )
 
+from ert.config import EverestConstraintsConfig, EverestControl, EverestObjectivesConfig
 from everest.config import (
-    ControlConfig,
     InputConstraintConfig,
     ModelConfig,
-    ObjectiveFunctionConfig,
-    OutputConstraintConfig,
 )
-from everest.config.utils import FlattenedControls
 
 
 class EverestOptModelTransforms(TypedDict):
@@ -429,19 +426,22 @@ class ConstraintScaler(NonLinearConstraintTransform):
 
 
 def get_optimization_domain_transforms(
-    controls: list[ControlConfig],
-    objectives: list[ObjectiveFunctionConfig],
+    controls: list[EverestControl],
+    objectives: EverestObjectivesConfig,
     input_constraints: list[InputConstraintConfig] | None,
-    output_constraints: list[OutputConstraintConfig] | None,
+    output_constraints: EverestConstraintsConfig | None,
     model: ModelConfig,
     auto_scale: bool,
 ) -> EverestOptModelTransforms:
-    flattened_controls = FlattenedControls(controls)
     control_scaler = ControlScaler(
-        flattened_controls.lower_bounds,
-        flattened_controls.upper_bounds,
-        flattened_controls.scaled_ranges,
-        flattened_controls.types,
+        [min_ for control in controls for min_ in control.min],
+        [max_ for control in controls for max_ in control.max],
+        [
+            scaled_range
+            for control in controls
+            for scaled_range in control.scaled_ranges
+        ],
+        [type_ for control in controls for type_ in control.control_types],
         auto_scale_input_constraints=auto_scale,
         input_constraint_scales=(
             None
@@ -461,14 +461,10 @@ def get_optimization_domain_transforms(
 
     objective_scaler = ObjectiveScaler(
         auto_scale=auto_scale,
-        scales=[
-            1.0 if objective.scale is None else objective.scale
-            for objective in objectives
-        ],
+        scales=[1.0 if scale is None else scale for scale in objectives.scales],
         realization_weights=realization_weights,
         objective_weights=[
-            1.0 if objective.weight is None else objective.weight
-            for objective in objectives
+            1.0 if weight is None else weight for weight in objectives.weights
         ],
     )
 
@@ -476,8 +472,7 @@ def get_optimization_domain_transforms(
         ConstraintScaler(
             auto_scale=auto_scale,
             scales=[
-                1.0 if constraint.scale is None else constraint.scale
-                for constraint in output_constraints
+                1.0 if scale is None else scale for scale in output_constraints.scales
             ],
             realization_weights=realization_weights,
         )

everest/optimizer/utils.py

@@ -1,29 +0,0 @@
-import importlib
-
-from ropt.plugins import PluginManager
-
-
-def get_ropt_plugin_manager() -> PluginManager:
-    # To check the validity of optimization and sampler backends and their
-    # supported algorithms or methods, an instance of a ropt PluginManager is
-    # needed. Everest also needs a ropt plugin manager at runtime which may add
-    # additional optimization and/or sampler backends. To be sure that these
-    # added backends are detected, all code should use this function to access
-    # the plugin manager. Any optimizer/sampler plugins that need to be added at
-    # runtime should be added in this function.
-    #
-    # Note: backends can also be added via the Python entrypoints mechanism,
-    # these are detected by default and do not need to be added here.
-
-    try:
-        return PluginManager()
-    except Exception as exc:
-        ert_version = importlib.metadata.version("ert")
-        ropt_version = importlib.metadata.version("ropt")
-        msg = (
-            f"Error while initializing ropt:\n\n{exc}.\n\n"
-            "Check the everest installation, there may a be version mismatch.\n"
-            f"  (ERT: {ert_version}, ropt: {ropt_version})\n"
-            "If the everest installation is correct, please report this as a bug."
-        )
-        raise RuntimeError(msg) from exc

everest/plugins/hook_specs.py

@@ -21,30 +21,6 @@ def install_job_directories() -> list[str]:  # type: ignore[empty-body]
     """
 
 
-@hookspec(firstresult=True)
-def ecl100_config_path() -> str:  # type: ignore[empty-body]
-    """
-    :return: Path to ecl100 config file
-    :rtype: PluginResponse with data as str
-    """
-
-
-@hookspec(firstresult=True)
-def ecl300_config_path() -> str:  # type: ignore[empty-body]
-    """
-    :return: Path to ecl300 config file
-    :rtype: PluginResponse with data as str
-    """
-
-
-@hookspec(firstresult=True)
-def flow_config_path() -> str:  # type: ignore[empty-body]
-    """
-    :return: Path to flow config file
-    :rtype: PluginResponse with data as str
-    """
-
-
 @hookspec(firstresult=True)
 def lint_forward_model(job: str, args: Sequence[str]) -> list[str]:  # type: ignore[empty-body]
     """

everest/strings.py

@@ -1,15 +1,11 @@
 from enum import StrEnum
 
-CERTIFICATE_DIR = "cert"
-
-DETACHED_NODE_DIR = "detached_node_output"
 DEFAULT_OUTPUT_DIR = "everest_output"
 DEFAULT_LOGGING_FORMAT = "%(asctime)s %(name)s %(levelname)s: %(message)s"
 
 EVEREST = "everest"
 EVERSERVER = "everserver"
-
-HOSTFILE_NAME = "storage_server.json"
+EXPERIMENT_SERVER = "experiment_server"
 
 NAME = "name"
 
@@ -22,7 +18,6 @@ OPT_FAILURE_REALIZATIONS = (
 OPT_FAILURE_ALL_REALIZATIONS = "Optimization failed: all realizations failed."
 
 SESSION_DIR = ".session"
-SERVER_STATUS = "status"
 SIMULATION = "simulation"
 SIMULATOR_START = "start"
 SIMULATOR_UPDATE = "update"

everest/util/__init__.py

@@ -8,6 +8,7 @@ try:
     from ert.shared.version import version as ert_version
 except ImportError:
     ert_version = "0.0.0"
+from _ert.utils import file_safe_timestamp
 from everest.strings import EVEREST
 
 
@@ -37,6 +38,7 @@ def warn_user_that_runpath_is_nonempty() -> None:
 
 def _roll_dir(old_name: str) -> None:
     old_name = os.path.realpath(old_name)
-    new_name = f"{old_name}__{datetime.now(UTC).isoformat()}"
+    timestamp = file_safe_timestamp(datetime.now(UTC).isoformat())
+    new_name = f"{old_name}__{timestamp}"
     os.rename(old_name, new_name)
     logging.getLogger(EVEREST).info(f"renamed {old_name} to {new_name}")

ert/config/everest_objective_config.py

@@ -1,95 +0,0 @@
-from pathlib import Path
-from typing import Literal, Self
-
-import numpy as np
-import polars as pl
-
-from ert.substitutions import substitute_runpath_name
-
-from .parsing import ConfigDict
-from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
-from .responses_index import responses_index
-
-
-class EverestObjectivesConfig(ResponseConfig):
-    type: Literal["everest_objectives"] = "everest_objectives"
-    name: str = "everest_objectives"
-    has_finalized_keys: bool = True
-
-    @property
-    def metadata(self) -> list[ResponseMetadata]:
-        return [
-            ResponseMetadata(
-                response_type=self.name,
-                response_key=response_key,
-                finalized=self.has_finalized_keys,
-                filter_on=None,
-            )
-            for response_key in self.keys
-        ]
-
-    @property
-    def expected_input_files(self) -> list[str]:
-        return self.input_files
-
-    @classmethod
-    def from_config_dict(cls, config_dict: ConfigDict) -> Self:
-        raise NotImplementedError("Should only be directly initialized")
-
-    def read_from_file(self, run_path: str, iens: int, iter_: int) -> pl.DataFrame:
-        def _read_file(filename: Path) -> pl.DataFrame:
-            try:
-                data = np.loadtxt(filename, ndmin=1)
-            except ValueError as err:
-                raise InvalidResponseFile(str(err)) from err
-            return pl.DataFrame(
-                {
-                    "values": pl.Series(data, dtype=pl.Float32),
-                }
-            )
-
-        errors = []
-
-        run_path_ = Path(run_path)
-        datasets_per_name = []
-
-        for name, input_file in zip(self.keys, self.input_files, strict=False):
-            datasets = []
-            try:
-                filename = substitute_runpath_name(input_file, iens, iter_)
-                datasets.append(_read_file(run_path_ / filename))
-            except (InvalidResponseFile, FileNotFoundError) as err:
-                errors.append(err)
-
-            if len(datasets) > 0:
-                combined_ds = pl.concat(datasets)
-                combined_ds.insert_column(
-                    0, pl.Series("response_key", [name] * len(combined_ds))
-                )
-                datasets_per_name.append(combined_ds)
-
-        if errors:
-            if all(isinstance(err, FileNotFoundError) for err in errors):
-                raise FileNotFoundError(
-                    "Could not find one or more files/directories while reading "
-                    f"{self.name}: {','.join([str(err) for err in errors])}"
-                )
-            else:
-                raise InvalidResponseFile(
-                    "Error reading "
-                    f"{self.name}, errors: {','.join([str(err) for err in errors])}"
-                )
-
-        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 []
-
-
-responses_index.add_response_type(EverestObjectivesConfig)

ert/config/ext_param_config.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import Iterator, Mapping, MutableMapping
-from dataclasses import field
-from pathlib import Path
-from typing import TYPE_CHECKING, Literal
-
-import networkx as nx
-import numpy as np
-import xarray as xr
-
-from ert.substitutions import substitute_runpath_name
-
-from .parameter_config import ParameterConfig, ParameterMetadata
-
-if TYPE_CHECKING:
-    import numpy.typing as npt
-
-    from ert.storage import Ensemble
-
-    Number = int | float
-    DataType = Mapping[str, Number | Mapping[str, Number]]
-    MutableDataType = MutableMapping[str, Number | MutableMapping[str, Number]]
-
-
-class ExtParamConfig(ParameterConfig):
-    """Create an ExtParamConfig 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
-    output_file: str = ""
-    forward_init_file: str = ""
-    update: bool = False
-
-    def read_from_runpath(
-        self, run_path: Path, real_nr: int, iteration: int
-    ) -> xr.Dataset:
-        raise NotImplementedError
-
-    def write_to_runpath(
-        self, run_path: Path, real_nr: int, ensemble: Ensemble
-    ) -> None:
-        file_path = run_path / substitute_runpath_name(
-            self.output_file, real_nr, ensemble.iteration
-        )
-        Path.mkdir(file_path.parent, exist_ok=True, parents=True)
-
-        data: MutableDataType = {}
-        for da in ensemble.load_parameters(self.name, real_nr)["values"]:
-            assert isinstance(da, xr.DataArray)
-            name = str(da.names.values)
-            try:
-                outer, inner = name.split("\0")
-
-                if outer not in data:
-                    data[outer] = {}
-                data[outer][inner] = float(da)  # type: ignore
-            except ValueError:
-                data[name] = float(da)
-
-        with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(data, f)
-
-    def create_storage_datasets(
-        self,
-        from_data: npt.NDArray[np.float64],
-        iens_active_index: npt.NDArray[np.int_],
-    ) -> Iterator[tuple[int, xr.Dataset]]:
-        for i, realization in enumerate(iens_active_index):
-            yield (
-                int(realization),
-                xr.Dataset(
-                    {
-                        "values": ("names", from_data[:, i]),
-                        "names": [
-                            x.split(f"{self.name}.")[1].replace(".", "\0")
-                            for x in self.parameter_keys
-                        ],
-                    }
-                ),
-            )
-
-    def load_parameters(
-        self, ensemble: Ensemble, realizations: npt.NDArray[np.int_]
-    ) -> npt.NDArray[np.float64]:
-        raise NotImplementedError
-
-    def load_parameter_graph(self) -> nx.Graph[int]:
-        raise NotImplementedError
-
-    def __len__(self) -> int:
-        return len(self.input_keys)

ert/gui/tools/export/__init__.py

@@ -1,3 +0,0 @@
-from .export_tool import ExportTool
-
-__all__ = ["ExportTool"]

ert/gui/tools/export/export_panel.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING
-
-from PyQt6.QtWidgets import QCheckBox, QWidget
-
-from ert.gui.ertwidgets import CustomDialog, ListEditBox, PathChooser, PathModel
-
-if TYPE_CHECKING:
-    from ert.config import ErtConfig
-    from ert.storage import LocalStorage
-
-
-class ExportDialog(CustomDialog):
-    def __init__(
-        self,
-        ert_config: ErtConfig,
-        storage: LocalStorage,
-        parent: QWidget | None = None,
-    ) -> None:
-        self.storage = storage
-        description = "The CSV export requires some information before it starts:"
-        super().__init__("export", description, parent)
-
-        subs_list = ert_config.substitutions
-        default_csv_output_path = subs_list.get("<CSV_OUTPUT_PATH>", "output.csv")
-        self.output_path_model = PathModel(default_csv_output_path)
-        output_path_chooser = PathChooser(self.output_path_model)
-
-        design_matrix_default = subs_list.get("<DESIGN_MATRIX_PATH>", "")
-        self.design_matrix_path_model = PathModel(
-            design_matrix_default, is_required=False, must_exist=True
-        )
-        design_matrix_path_chooser = PathChooser(self.design_matrix_path_model)
-
-        ensemble_with_data_dict = {
-            ensemble.id: ensemble.name
-            for ensemble in storage.ensembles
-            if ensemble.has_data()
-        }
-        self.list_edit = ListEditBox(ensemble_with_data_dict)
-
-        self.drop_const_columns_check = QCheckBox()
-        self.drop_const_columns_check.setChecked(False)
-        self.drop_const_columns_check.setToolTip(
-            "If checked, exclude columns whose value is the same for every entry"
-        )
-
-        self.addLabeledOption("Output file path", output_path_chooser)
-        self.addLabeledOption("Design matrix path", design_matrix_path_chooser)
-        self.addLabeledOption("List of ensembles to export", self.list_edit)
-        self.addLabeledOption("Drop constant columns", self.drop_const_columns_check)
-
-        self.addButtons()
-
-    @property
-    def output_path(self) -> str | None:
-        return self.output_path_model.getPath()
-
-    @property
-    def ensemble_data_as_json(self) -> str:
-        ensembles = {
-            str(ensemble.id): {
-                "ensemble_name": ensemble.name,
-                "experiment_name": ensemble.experiment.name,
-            }
-            for ensemble in self.storage.ensembles
-            if ensemble.name in self.list_edit.getItems().values()
-        }
-
-        return json.dumps(ensembles)
-
-    @property
-    def design_matrix_path(self) -> str | None:
-        path = self.design_matrix_path_model.getPath()
-        if not path or not path.strip():
-            path = None
-        return path
-
-    @property
-    def drop_const_columns(self) -> bool:
-        return self.drop_const_columns_check.isChecked()

ert/gui/tools/export/export_tool.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any, cast, no_type_check
-
-from PyQt6.QtGui import QIcon
-from PyQt6.QtWidgets import QMessageBox, QWidget
-
-if TYPE_CHECKING:
-    from ert.config import ErtConfig
-
-from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.tools import Tool
-from ert.gui.tools.export.export_panel import ExportDialog
-
-from .exporter import Exporter
-
-logger = logging.getLogger(__name__)
-
-
-class ExportTool(Tool):
-    def __init__(self, config: ErtConfig, notifier: ErtNotifier) -> None:
-        super().__init__("Export data", QIcon("img:share.svg"))
-        export_job = config.workflow_jobs.get("CSV_EXPORT")
-        self.setEnabled(export_job is not None)
-        self.__exporter = Exporter(
-            export_job,
-            notifier,
-            config,
-        )
-        self.config = config
-        self.notifier = notifier
-
-    @no_type_check
-    def trigger(self) -> None:
-        dialog = ExportDialog(self.config, self.notifier.storage, self.parent())
-        success = dialog.showAndTell()
-
-        if success:
-            logger.info("Gui utility: Export CSV tool was used")
-            self._run_export(
-                [
-                    dialog.output_path,
-                    dialog.ensemble_data_as_json,
-                    dialog.design_matrix_path,
-                    True,
-                    dialog.drop_const_columns,
-                ]
-            )
-
-    def _run_export(self, params: list[Any]) -> None:
-        try:
-            self.__exporter.run_export(params)
-            QMessageBox.information(
-                cast(QWidget, self.parent()),
-                "Success",
-                """Export completed!""",
-                QMessageBox.StandardButton.Ok,
-            )
-        except UserWarning as usrwarning:
-            logger.error(str(usrwarning))
-            QMessageBox.warning(
-                cast(QWidget, self.parent()),
-                "Failure",
-                f"Export failed with the following message:\n{usrwarning}",
-                QMessageBox.StandardButton.Ok,
-            )

ert/gui/tools/export/exporter.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from ert.config import ErtConfig, WorkflowJob
-
-from ert.gui.ertnotifier import ErtNotifier
-from ert.workflow_runner import WorkflowJobRunner
-
-logger = logging.getLogger(__name__)
-
-
-class Exporter:
-    def __init__(
-        self,
-        export_job: WorkflowJob | None,
-        notifier: ErtNotifier,
-        config: ErtConfig,
-    ) -> None:
-        self.config = config
-        self.export_job = export_job
-        self._notifier = notifier
-
-    def run_export(self, parameters: list[Any]) -> None:
-        if self.export_job is None:
-            raise UserWarning("Could not find export_job job")
-
-        export_job_runner = WorkflowJobRunner(self.export_job)
-        user_warn = export_job_runner.run(
-            fixtures={"storage": self._notifier.storage},
-            arguments=parameters,
-        )
-        if export_job_runner.hasFailed():
-            raise UserWarning(f"Failed to execute {self.export_job.name}\n{user_warn}")

ert/plugins/hook_specifications/ecl_config.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from ert.plugins.plugin_manager import hook_specification
-
-if TYPE_CHECKING:
-    from ert.plugins.plugin_response import PluginResponse
-
-
-@hook_specification(firstresult=True)
-def ecl100_config_path() -> PluginResponse[str]:  # type: ignore
-    """
-    :return: Path to ecl100 config file
-    """
-
-
-@hook_specification(firstresult=True)
-def ecl300_config_path() -> PluginResponse[str]:  # type: ignore
-    """
-    :return: Path to ecl300 config file
-    """
-
-
-@hook_specification(firstresult=True)
-def flow_config_path() -> PluginResponse[str]:  # type: ignore
-    """
-    :return: Path to flow config file
-    """