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

everest/bin/everlint_script.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import argparse
 import warnings
 from functools import partial
@@ -11,19 +9,19 @@ from everest.config import EverestConfig
 def _build_args_parser() -> argparse.ArgumentParser:
     """Build arg parser"""
     arg_parser = argparse.ArgumentParser(
-        description="Check if a config file is valid",
+        description="Check if a configuration file is valid.",
         usage="""everest lint <config_file>""",
     )
     arg_parser.add_argument(
         "config",
         type=partial(EverestConfig.load_file_with_argparser, parser=arg_parser),
-        help="The path to the everest configuration file",
+        help="The path to the everest configuration file.",
     )
     arg_parser.add_argument(
         "-v",
         "--verbose",
         action="store_true",
-        help="Display verbose errors and warnings",
+        help="Display verbose errors and warnings.",
     )
     return arg_parser
 

everest/bin/kill_script.py

@@ -12,7 +12,7 @@ from functools import partial
 from pathlib import Path
 from typing import Any
 
-from ert.services import StorageService
+from ert.services import ErtServer
 from everest.bin.utils import setup_logging
 from everest.config import EverestConfig, ServerConfig
 from everest.detached import stop_server, wait_for_server_to_stop
@@ -39,16 +39,18 @@ def _build_args_parser() -> argparse.ArgumentParser:
     """Build arg parser"""
 
     arg_parser = argparse.ArgumentParser(
-        description="Kill a running optimization case based on a given config file",
+        description="Kill a running optimization process.",
         usage="everest kill <config_file>",
     )
     arg_parser.add_argument(
         "config",
         type=partial(EverestConfig.load_file_with_argparser, parser=arg_parser),
-        help="The path to the everest configuration file",
+        help="The path to the everest configuration file.",
     )
     arg_parser.add_argument(
-        "--debug", action="store_true", help="Display debug information in the terminal"
+        "--debug",
+        action="store_true",
+        help="Display debug information in the terminal.",
     )
 
     return arg_parser
@@ -72,7 +74,7 @@ def _handle_keyboard_interrupt(signal: int, _: Any, after: bool = False) -> None
 
 def kill_everest(options: argparse.Namespace) -> None:
     try:
-        client = StorageService.session(
+        client = ErtServer.session(
             Path(ServerConfig.get_session_dir(options.config.output_dir)), timeout=1
         )
         server_context = ServerConfig.get_server_context_from_conn_info(

everest/bin/main.py

@@ -9,7 +9,6 @@ from ert.trace import tracer
 from everest.bin.config_branch_script import config_branch_entry
 from everest.bin.everconfigdump_script import config_dump_entry
 from everest.bin.everest_script import everest_entry
-from everest.bin.everexport_script import everexport_entry
 from everest.bin.everlint_script import lint_entry
 from everest.bin.kill_script import kill_entry
 from everest.bin.monitor_script import monitor_entry
@@ -19,10 +18,10 @@ from everest.bin.visualization_script import visualization_entry
 def _build_args_parser() -> argparse.ArgumentParser:
     """Build arg parser"""
     arg_parser = argparse.ArgumentParser(
-        description="Tool for performing reservoir management optimization",
+        description="Tool for performing reservoir management optimization.",
         usage=(
             "everest <command> [<args>]\n\n"
-            "The most commonly used everest commands are:\n"
+            "Supported commands:\n"
             f"{EverestMain.methods_help()}\n\n"
             "Run everest <command> --help for more information on a command"
         ),
@@ -51,52 +50,40 @@ class EverestMain:
     @classmethod
     def methods_help(cls) -> str:
         """Return documentation of the public methods in this class"""
-        pubmets = [m for m in dir(cls) if not m.startswith("_")]
-        pubmets.remove("methods_help")  # Current method should not show up in desc
+        pubmets = ["run", "monitor", "kill", "lint", "render", "branch", "results"]
         maxlen = max(len(m) for m in pubmets)
         docstrs = [getattr(cls, m).__doc__ for m in pubmets]
         doclist = [
-            m.ljust(maxlen + 1) + d for m, d in zip(pubmets, docstrs, strict=False)
+            m.ljust(maxlen + 2) + d for m, d in zip(pubmets, docstrs, strict=False)
         ]
         return "\n".join(doclist)
 
     def run(self, args: list[str]) -> None:
-        """Start an optimization case base on given config file"""
+        """Start an optimization run"""
         everest_entry(args)
 
     def monitor(self, args: list[str]) -> None:
-        """Monitor a running optimization case base on given config file"""
+        """Monitor a running optimization"""
         monitor_entry(args)
 
     def kill(self, args: list[str]) -> None:
-        """Kill a running optimization case base on given config file"""
+        """Kill a running optimization"""
         kill_entry(args)
 
-    def gui(self, _: list[str]) -> None:
-        """Start the graphical user interface (Removed)"""
-        print(
-            "The gui command has been removed. "
-            "Please use the run command with the --gui option instead."
-        )
-
-    def export(self, args: list[str]) -> None:
-        """Export data from a completed optimization case"""
-        everexport_entry(args)
-
     def lint(self, args: list[str]) -> None:
-        """Validate a config file"""
+        """Validate the configuration file"""
         lint_entry(args)
 
     def render(self, args: list[str]) -> None:
-        """Display the configuration data loaded from a config file"""
+        """Display the configuration data"""
         config_dump_entry(args)
 
     def branch(self, args: list[str]) -> None:
-        """Construct possible restart config file"""
+        """Construct a new configuration file from a given batch"""
         config_branch_entry(args)
 
     def results(self, args: list[str]) -> None:
-        """Start everest visualization plugin"""
+        """Start the everest visualization plugin"""
         visualization_entry(args)
 
 

everest/bin/monitor_script.py

@@ -5,15 +5,17 @@ import signal
 import threading
 from functools import partial
 from pathlib import Path
+from textwrap import dedent
 
-from ert.services import StorageService
+from ert.services import ErtServer
+from ert.storage import ErtStorageException, ExperimentState
 from everest.config import EverestConfig, ServerConfig
-from everest.detached import ExperimentState, everserver_status
 from everest.everest_storage import EverestStorage
 
 from .utils import (
+    ArgParseFormatter,
+    get_experiment_status,
     handle_keyboard_interrupt,
-    report_on_previous_run,
     run_detached_monitor,
     setup_logging,
 )
@@ -42,25 +44,35 @@ def _build_args_parser() -> argparse.ArgumentParser:
     """Build arg parser"""
 
     arg_parser = argparse.ArgumentParser(
-        description=(
-            "Everest console monitor a running optimization case based on a config file"
+        description=dedent(
+            """
+            Monitor a running optimization process.
+
+            Closing the console or interrupting the `everest run` process does
+            not terminate the optimization process. To continue monitoring the
+            running optimization, use `everest monitor config_file.yml`. To stop
+            a running optimization, use `everest kill config_file.yml`.
+            """
         ),
+        formatter_class=ArgParseFormatter,
         usage="everest monitor <config_file>",
     )
     arg_parser.add_argument(
         "config",
         type=partial(EverestConfig.load_file_with_argparser, parser=arg_parser),
-        help="The path to the everest configuration file",
+        help="The path to the everest configuration file.",
     )
     arg_parser.add_argument(
-        "--debug", action="store_true", help="Display debug information in the terminal"
+        "--debug",
+        action="store_true",
+        help="Display debug information in the terminal.",
     )
     arg_parser.add_argument(
         "--show-all-jobs",
         action="store_true",
         help=(
             "This option no longer has an effect, "
-            "and will be removed in a future version"
+            "and will be removed in a future version."
         ),
     )
 
@@ -69,37 +81,54 @@ def _build_args_parser() -> argparse.ArgumentParser:
 
 def monitor_everest(options: argparse.Namespace) -> None:
     config: EverestConfig = options.config
-    status_path = ServerConfig.get_everserver_status_path(config.output_dir)
-    server_state = everserver_status(status_path)
-
     try:
-        client = StorageService.session(
+        with ErtServer.session(
             Path(ServerConfig.get_session_dir(config.output_dir)), timeout=1
-        )
-        server_context = ServerConfig.get_server_context_from_conn_info(
-            client.conn_info
-        )
-        run_detached_monitor(server_context=server_context)
-        server_state = everserver_status(status_path)
-        if server_state["status"] == ExperimentState.failed:
-            raise SystemExit(server_state["message"])
-        if server_state["message"] is not None:
-            print(server_state["message"])
+        ) as client:
+            server_context = ServerConfig.get_server_context_from_conn_info(
+                client.conn_info
+            )
+            run_detached_monitor(server_context=server_context)
+
+            try:
+                experiment_status = get_experiment_status(config.storage_dir)
+                if (
+                    experiment_status
+                    and experiment_status.status == ExperimentState.failed
+                ):
+                    raise SystemExit(experiment_status.message or "Optimization failed")
+                if experiment_status:
+                    print(
+                        experiment_status.message
+                        or "Optimization completed successfully"
+                    )
+            except ErtStorageException as err:
+                print(f"Error reading experiment status: {err}")
 
     except TimeoutError:
-        if server_state["status"] == ExperimentState.never_run:
-            config_file = config.config_file
-            print(
-                "The optimization has not run yet.\n"
-                "To run the optimization use command:\n"
-                f"  `everest run {config_file}`"
-            )
-        else:
-            report_on_previous_run(
-                config_file=config.config_file,
-                everserver_status_path=status_path,
-                optimization_output_dir=config.optimization_output_dir,
-            )
+        try:
+            experiment_status = get_experiment_status(config.storage_dir)
+            if (
+                experiment_status is None
+                or experiment_status.status == ExperimentState.never_run
+            ):
+                print(
+                    "The optimization has not run yet.\n"
+                    "To run the optimization use command:\n"
+                    f"  `everest run {config.config_file}`"
+                )
+            elif experiment_status.status == ExperimentState.failed:
+                print(
+                    "Optimization run failed, with error: "
+                    f"{experiment_status.message}\n"
+                )
+            else:
+                print(
+                    "Optimization already completed.\n"
+                    f"Results are stored in {config.optimization_output_dir}"
+                )
+        except ErtStorageException as err:
+            print(f"Error reading experiment status: {err}")
 
 
 if __name__ == "__main__":

everest/bin/utils.py

@@ -1,6 +1,6 @@
 import argparse
 import json
-import logging
+import logging.config
 import os
 import sys
 import traceback
@@ -23,23 +23,29 @@ from ert.ensemble_evaluator import (
     FullSnapshotEvent,
     SnapshotUpdateEvent,
 )
+from ert.ensemble_evaluator.event import EndEvent
 from ert.logging import LOGGING_CONFIG
 from ert.plugins.plugin_manager import ErtPluginManager
-from ert.services import StorageService
+from ert.services import ErtServer
+from ert.storage import (
+    ExperimentStatus,
+    open_storage,
+)
 from everest.config import EverestConfig
 from everest.config.server_config import ServerConfig
 from everest.detached import (
-    ExperimentState,
-    everserver_status,
     server_is_running,
     start_monitor,
     stop_server,
     wait_for_server_to_stop,
 )
-from everest.simulator import JOB_FAILURE, JOB_RUNNING, JOB_SUCCESS
 from everest.strings import EVEREST, OPT_PROGRESS_ID, SIM_PROGRESS_ID
 from everest.util import makedirs_if_needed
 
+JOB_SUCCESS = "Finished"
+JOB_RUNNING = "Running"
+JOB_FAILURE = "Failed"
+
 
 def cleanup_logging() -> None:
     os.environ.pop("ERT_LOG_DIR", None)
@@ -61,22 +67,21 @@ def setup_logging(options: argparse.Namespace) -> Generator[None, None, None]:
     try:
         os.environ["ERT_LOG_DIR"] = str(log_dir)
 
-        with open(LOGGING_CONFIG, encoding="utf-8") as log_conf_file:
-            config_dict = yaml.safe_load(log_conf_file)
-            if config_dict:
-                for handler_name, handler_config in config_dict["handlers"].items():
-                    if handler_name == "file":
-                        handler_config["filename"] = "everest-log.txt"
-                    if "ert.logging.TimestampedFileHandler" in handler_config.values():
-                        handler_config["config_filename"] = ""
-                        if isinstance(options.config, EverestConfig):
-                            handler_config["config_filename"] = (
-                                options.config.config_path.name
-                            )
-                        else:
-                            # `everest branch`
-                            handler_config["config_filename"] = options.config[0]
-                logging.config.dictConfig(config_dict)
+        config_dict = yaml.safe_load(LOGGING_CONFIG.read_text(encoding="utf-8"))
+        if config_dict:
+            for handler_name, handler_config in config_dict["handlers"].items():
+                if handler_name == "file":
+                    handler_config["filename"] = "everest-log.txt"
+                if "ert.logging.TimestampedFileHandler" in handler_config.values():
+                    handler_config["config_filename"] = ""
+                    if isinstance(options.config, EverestConfig):
+                        handler_config["config_filename"] = (
+                            options.config.config_path.name
+                        )
+                    else:
+                        # `everest branch`
+                        handler_config["config_filename"] = options.config[0]
+            logging.config.dictConfig(config_dict)
 
         if "debug" in options and options.debug:
             root_logger = logging.getLogger()
@@ -101,7 +106,7 @@ def handle_keyboard_interrupt(signum: int, _: Any, options: argparse.Namespace)
             "The optimization will be stopped and the program will exit..."
         )
         try:
-            client = StorageService.session(
+            client = ErtServer.session(
                 Path(ServerConfig.get_session_dir(options.config.output_dir))
             )
             server_context = ServerConfig.get_server_context_from_conn_info(
@@ -216,6 +221,8 @@ class _DetachedMonitor:
                     self._clear_lines = 0
             if SIM_PROGRESS_ID in status:
                 match status[SIM_PROGRESS_ID]:
+                    case EndEvent(msg=msg):
+                        return
                     case FullSnapshotEvent(snapshot=snapshot, iteration=batch):
                         if snapshot is not None:
                             self._snapshots[batch] = snapshot
@@ -372,7 +379,8 @@ class _DetachedMonitor:
     def _get_jobs_status(snapshot: EnsembleSnapshot) -> list[JobProgress]:
         job_progress = {}
         for (realization, job_idx), job in snapshot.get_all_fm_steps().items():
-            assert "name" in job and job["name"] is not None, "job name is missing"
+            assert "name" in job, "job name is missing"
+            assert job["name"] is not None, "job name is None"
             name = job["name"]
             if job_idx not in job_progress:
                 job_progress[job_idx] = JobProgress(name=name)
@@ -406,7 +414,9 @@ class _DetachedMonitor:
             print(colorama.Cursor.UP(), end=colorama.ansi.clear_line())
 
 
-def run_detached_monitor(server_context: tuple[str, str, tuple[str, str]]) -> None:
+def run_detached_monitor(
+    server_context: tuple[str, str, tuple[str, str]],
+) -> None:
     monitor = _DetachedMonitor()
     start_monitor(server_context, callback=monitor.update)
 
@@ -417,30 +427,15 @@ def run_empty_detached_monitor(
     start_monitor(server_context, callback=lambda _: None)
 
 
-def report_on_previous_run(
-    config_file: str,
-    everserver_status_path: str,
-    optimization_output_dir: str,
-) -> None:
-    server_state = everserver_status(everserver_status_path)
-    if server_state["status"] == ExperimentState.failed:
-        error_msg = server_state["message"]
-        print(f"Optimization run failed, with error: {error_msg}\n")
-    else:
-        print(
-            f"Optimization completed.\nResults are stored in {optimization_output_dir}"
-        )
-
-
 def _read_user_preferences(user_info_path: Path) -> dict[str, dict[str, Any]]:
     try:
         if user_info_path.exists():
-            with open(user_info_path, encoding="utf-8") as f:
-                return json.load(f)
+            return json.loads(user_info_path.read_text(encoding="utf-8"))
 
         user_info = {EVEREST: {"show_scaling_warning": True}}
-        with open(user_info_path, mode="w", encoding="utf-8") as f:
-            json.dump(user_info, f, ensure_ascii=False, indent=4)
+        user_info_path.write_text(
+            json.dumps(user_info, ensure_ascii=False, indent=4), encoding="utf-8"
+        )
     except json.decoder.JSONDecodeError:
         return {EVEREST: {}}
     else:
@@ -477,3 +472,23 @@ def show_scaled_controls_warning() -> None:
                 logging.getLogger(EVEREST).error(str(e))
         case "n":
             raise SystemExit(0)
+
+
+def get_experiment_status(storage_dir: str) -> ExperimentStatus | None:
+    """
+    Reads the experiment status from storage. We assume that there is
+    only one experiment for each everest run in storage.
+    """
+    with open_storage(storage_dir, "r") as storage:
+        experiments = list(storage.experiments)
+        return None if not experiments else experiments[0].status
+
+
+class ArgParseFormatter(argparse.HelpFormatter):
+    def _fill_text(self, text: str, width: int, indent: str) -> str:
+        return "\n\n".join(
+            [
+                argparse.HelpFormatter._fill_text(self, p, width, indent)
+                for p in text.split("\n\n")
+            ]
+        )

everest/bin/visualization_script.py

@@ -1,28 +1,43 @@
-#!/usr/bin/env python
-
 import argparse
 import logging
 import sys
 from functools import partial
 from pathlib import Path
+from textwrap import dedent
 
-from ert.storage import ErtStorageException, open_storage
+from ert.storage import LocalStorage
 from everest.api import EverestDataAPI
 from everest.bin.utils import setup_logging
 from everest.config import EverestConfig
 from everest.everest_storage import EverestStorage
 from everest.plugins.everest_plugin_manager import EverestPluginManager
 
+from .utils import ArgParseFormatter
+
 
 def _build_args_parser() -> argparse.ArgumentParser:
     arg_parser = argparse.ArgumentParser(
-        description="Start possible plugin containing everest visualization",
+        description=dedent(
+            """
+            Start an everest visualization plugin.
+
+            If no visualization plugin is installed the message: ``No
+            visualization plugin installed!`` will be displayed in the console.
+
+            The recommended open-source everest visualization plugin is Everviz:
+
+            https://github.com/equinor/everviz
+
+            It can be installed using ``pip install everviz``.
+            """
+        ),
+        formatter_class=ArgParseFormatter,
         usage="""everest results <config_file>""",
     )
     arg_parser.add_argument(
         "config",
         type=partial(EverestConfig.load_file_with_argparser, parser=arg_parser),
-        help="The path to the everest configuration file",
+        help="The path to the everest configuration file.",
     )
     return arg_parser
 
@@ -38,14 +53,9 @@ def visualization_entry(args: list[str] | None = None) -> None:
             ever_config.optimization_output_dir
         )
 
-        try:
-            # If successful, no need to migrate
-            open_storage(ever_config.storage_dir, mode="r").close()
-        except ErtStorageException as err:
-            if "too old" in str(err):
-                # Open write storage to do a migration
-                logger.info("Migrating ERT storage from everviz entrypoint")
-                open_storage(ever_config.storage_dir, mode="w").close()
+        if LocalStorage.check_migration_needed(Path(ever_config.storage_dir)):
+            logger.info("Migrating ERT storage from everviz entrypoint")
+            LocalStorage.perform_migration(Path(ever_config.storage_dir))
 
         storage = EverestStorage(output_dir=Path(ever_config.optimization_output_dir))
         storage.read_from_output_dir()

everest/config/__init__.py

@@ -1,3 +1,5 @@
+from ert.config import SamplerConfig
+
 from .control_config import ControlConfig
 from .control_variable_config import (
     ControlVariableConfig,
@@ -6,6 +8,7 @@ from .control_variable_config import (
 from .cvar_config import CVaRConfig
 from .environment_config import EnvironmentConfig
 from .everest_config import EverestConfig, EverestValidationError
+from .forward_model_config import ForwardModelStepConfig
 from .input_constraint_config import InputConstraintConfig
 from .install_data_config import InstallDataConfig
 from .install_job_config import InstallJobConfig
@@ -14,7 +17,6 @@ from .model_config import ModelConfig
 from .objective_function_config import ObjectiveFunctionConfig
 from .optimization_config import OptimizationConfig
 from .output_constraint_config import OutputConstraintConfig
-from .sampler_config import SamplerConfig
 from .server_config import ServerConfig
 from .simulator_config import SimulatorConfig
 from .well_config import WellConfig
@@ -28,6 +30,7 @@ __all__ = [
     "EnvironmentConfig",
     "EverestConfig",
     "EverestValidationError",
+    "ForwardModelStepConfig",
     "InputConstraintConfig",
     "InstallDataConfig",
     "InstallJobConfig",