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

everest/config/control_variable_config.py

@@ -201,7 +201,7 @@ class ControlVariableConfig(_ControlVariable):
     def __hash__(self) -> int:
         return hash(self.name) + hash(self.index)
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, self.__class__)
             and other.name == self.name
@@ -234,7 +234,7 @@ class ControlVariableGuessListConfig(_ControlVariable):
     def __hash__(self) -> int:
         return hash(self.name)
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, self.__class__) and other.name == self.name
 
     @property

everest/config/everest_config.py

@@ -2,6 +2,7 @@ import logging
 import os
 from argparse import ArgumentParser
 from copy import copy
+from enum import StrEnum
 from itertools import chain
 from pathlib import Path
 from sys import float_info
@@ -28,6 +29,8 @@ from pydantic.json_schema import SkipJsonSchema
 from pydantic_core import ErrorDetails
 from pydantic_core.core_schema import ValidationInfo
 from ruamel.yaml import YAML, YAMLError
+from ruamel.yaml.nodes import ScalarNode
+from ruamel.yaml.representer import Representer
 
 from ert.base_model_context import BaseModelWithContextSupport, use_runtime_plugins
 from ert.config import (
@@ -1100,6 +1103,12 @@ to read summary data from forward model, do:
         yaml = YAML(typ="safe", pure=True) if safe_and_pure else YAML()
         yaml.indent(mapping=2, sequence=4, offset=2)
         yaml.preserve_quotes = True
+
+        def strenum_representer(dumper: Representer, data: StrEnum) -> ScalarNode:
+            return dumper.represent_str(data.value)
+
+        yaml.representer.add_multi_representer(StrEnum, strenum_representer)
+
         yaml.default_flow_style = False
         yaml.dump(config, output_file)
 

everest/config/utils.py

@@ -1,8 +1,8 @@
-from ert.config import ExtParamConfig, SamplerConfig
+from ert.config import EverestControl, SamplerConfig
 
 
 def get_samplers(
-    controls: list[ExtParamConfig],
+    controls: list[EverestControl],
 ) -> tuple[list[SamplerConfig | None], list[int]]:
     """
     Create a list of unique samplers, and a list mapping variable index

everest/config/validation_utils.py

@@ -1,6 +1,7 @@
 import errno
 import os
 import tempfile
+import types
 from collections import Counter
 from collections.abc import Sequence
 from pathlib import Path
@@ -104,7 +105,12 @@ class InstallDataContext:
             if data.source is not None and "<REALIZATION_ID>" in data.source:
                 self._set_symlink(data.source, data.target, realization)
 
-    def __exit__(self, exc_type: Any, exc_value: Any, exc_tb: Any) -> None:
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
         if self._temp_dir:
             self._temp_dir.cleanup()
         os.chdir(self._cwd)

everest/config_file_loader.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import logging
 import os
 import re

everest/detached/client.py

@@ -81,7 +81,7 @@ def stop_server(
     for retry in range(retries):
         try:
             url, cert, auth = server_context
-            stop_endpoint = "/".join([url, EverEndpoints.stop])
+            stop_endpoint = f"{url}/{EverEndpoints.stop}"
             response = requests.post(
                 stop_endpoint,
                 verify=cert,
@@ -105,7 +105,7 @@ def start_experiment(
     for retry in range(retries):
         try:
             url, cert, auth = server_context
-            start_endpoint = "/".join([url, EverEndpoints.start_experiment])
+            start_endpoint = f"{url}/{EverEndpoints.start_experiment}"
             response = requests.post(
                 start_endpoint,
                 verify=cert,
@@ -126,7 +126,7 @@ def extract_errors_from_file(path: str) -> list[str]:
     return re.findall(r"(Error \w+.*)", Path(path).read_text(encoding="utf-8"))
 
 
-def wait_for_server(client: Client, timeout: int | float) -> None:
+def wait_for_server(client: Client, timeout: float) -> None:
     """
     Waits until the everest server has started. Polls every second
     for server availability until timeout (measured in seconds).

everest/everest_storage.py

@@ -540,8 +540,6 @@ class EverestStorage:
             }
         )
 
-        # TODO: The weight and normalization keys are only used by the everest api,
-        # with everviz. They should be removed in the long run.
         weights = np.fromiter(
             (
                 1.0 if weight is None else weight

everest/gui/everest_client.py

@@ -44,7 +44,7 @@ class EverestClient:
 
     def _http_get(self, endpoint: EverEndpoints) -> requests.Response:
         return requests.get(
-            "/".join([self._url, endpoint]),
+            f"{self._url}/{endpoint}",
             verify=self._cert,
             auth=(self._username, self._password),
             proxies={"http": None, "https": None},  # type: ignore
@@ -52,7 +52,7 @@ class EverestClient:
 
     def _http_post(self, endpoint: EverEndpoints) -> requests.Response:
         return requests.post(
-            "/".join([self._url, endpoint]),
+            f"{self._url}/{endpoint}",
             verify=self._cert,
             auth=(self._username, self._password),
             proxies={"http": None, "https": None},  # type: ignore

everest/optimizer/everest2ropt.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from ropt.enums import PerturbationType, VariableType
 
-from ert.config import EverestConstraintsConfig, EverestObjectivesConfig, ExtParamConfig
+from ert.config import EverestConstraintsConfig, EverestControl, EverestObjectivesConfig
 from everest.config import (
     InputConstraintConfig,
     ModelConfig,
@@ -14,7 +14,7 @@ from everest.config.utils import get_samplers
 
 
 def _parse_controls(
-    controls: list[ExtParamConfig], random_seed: int
+    controls: list[EverestControl], random_seed: int
 ) -> tuple[dict[str, Any], list[dict[str, Any]] | None]:
     control_types = [
         VariableType[type_.upper()]
@@ -116,7 +116,7 @@ def _get_bounds(
 
 def _parse_input_constraints(
     input_constraints: list[InputConstraintConfig],
-    controls: list[ExtParamConfig],
+    controls: list[EverestControl],
 ) -> dict[str, Any]:
     formatted_control_names = [
         name for config in controls for name in config.input_keys
@@ -275,7 +275,7 @@ def _parse_optimization(
 
 
 def everest2ropt(
-    controls: list[ExtParamConfig],
+    controls: list[EverestControl],
     objective_functions: EverestObjectivesConfig,
     input_constraints: list[InputConstraintConfig],
     output_constraints: EverestConstraintsConfig | None,

everest/optimizer/opt_model_transforms.py

@@ -11,7 +11,7 @@ from ropt.transforms.base import (
     VariableTransform,
 )
 
-from ert.config import EverestConstraintsConfig, EverestObjectivesConfig, ExtParamConfig
+from ert.config import EverestConstraintsConfig, EverestControl, EverestObjectivesConfig
 from everest.config import (
     InputConstraintConfig,
     ModelConfig,
@@ -426,7 +426,7 @@ class ConstraintScaler(NonLinearConstraintTransform):
 
 
 def get_optimization_domain_transforms(
-    controls: list[ExtParamConfig],
+    controls: list[EverestControl],
     objectives: EverestObjectivesConfig,
     input_constraints: list[InputConstraintConfig] | None,
     output_constraints: EverestConstraintsConfig | None,

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,69 +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
-from typing_extensions import override
-
-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
-
-    @override
-    @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}")