ert 16.0.2__py3-none-any.whl → 17.0.0__py3-none-any.whl

_ert/forward_model_runner/fm_dispatch.py

@@ -8,6 +8,7 @@ import sys
 import time
 from collections.abc import Generator, Iterable
 from datetime import datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from _ert.forward_model_runner import reporting
@@ -19,6 +20,7 @@ from _ert.forward_model_runner.reporting.message import (
     ProcessTreeStatus,
 )
 from _ert.forward_model_runner.runner import ForwardModelRunner
+from _ert.utils import file_safe_timestamp
 
 if TYPE_CHECKING:
     from ert.config.forward_model_step import ForwardModelJSON
@@ -81,10 +83,10 @@ def _setup_logging(directory: str = "logs") -> None:
         "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
 
-    filename = (
-        f"forward-model-runner-log-{datetime.now().isoformat(timespec='minutes')}.txt"
-    )
-    csv_filename = f"memory-profile-{datetime.now().isoformat(timespec='minutes')}.csv"
+    timestamp = file_safe_timestamp(datetime.now().isoformat(timespec="minutes"))
+
+    filename = f"forward-model-runner-log-{timestamp}.txt"
+    csv_filename = f"memory-profile-{timestamp}.csv"
 
     handler = logging.FileHandler(filename=directory + "/" + filename)
     handler.setFormatter(formatter)
@@ -107,8 +109,9 @@ def _wait_for_retry() -> None:
 
 def _read_fm_description_file(retry: bool = True) -> "ForwardModelDescriptionJSON":
     try:
-        with open(FORWARD_MODEL_DESCRIPTION_FILE, encoding="utf-8") as json_file:
-            return json.load(json_file)
+        return json.loads(
+            Path(FORWARD_MODEL_DESCRIPTION_FILE).read_text(encoding="utf-8")
+        )
     except json.JSONDecodeError as e:
         raise OSError(
             "fm_dispatch failed to load JSON-file describing the forward model."

_ert/forward_model_runner/reporting/event.py

@@ -137,6 +137,7 @@ class Event(Reporter):
                 return
             except ClientConnectionError as exc:
                 logger.error(f"Failed to send event: {exc}")
+                self._reporter_exception = exc
                 return
             except queue.Empty:
                 await asyncio.sleep(0)

_ert/forward_model_runner/runner.py

@@ -40,8 +40,7 @@ class ForwardModelRunner:
     def _read_manifest(self) -> dict[str, Manifest] | None:
         if not Path("manifest.json").exists():
             return None
-        with open("manifest.json", encoding="utf-8") as f:
-            data = json.load(f)
+        data = json.loads(Path("manifest.json").read_text(encoding="utf-8"))
         return {
             name: {"type": "file", "path": str(Path(file).absolute())}
             for name, file in data.items()

_ert/utils.py

@@ -0,0 +1,12 @@
+def file_safe_timestamp(timestamp: str) -> str:
+    """
+    Convert an ISO timestamp string to a file-safe version
+
+    Keeps the date in the extended format (YYYY-MM-DD) and converts the time
+    to the basic format (HHMMSS) by removing colons. This mix is not strictly
+    ISO 8601 compliant, but it can still be parsed.
+
+    Example:
+    2025-10-10T14:30:00 -> 2025-10-10T143000
+    """
+    return str(timestamp).replace(":", "")

ert/__main__.py

@@ -12,6 +12,7 @@ import sys
 import warnings
 from argparse import ArgumentParser, ArgumentTypeError
 from collections.abc import Sequence
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
@@ -20,6 +21,7 @@ from opentelemetry.trace import Status, StatusCode
 
 import ert.shared
 from _ert.threading import set_signal_handler
+from ert.base_model_context import use_runtime_plugins
 from ert.cli.main import ErtCliError, run_cli
 from ert.config import ConfigValidationError, ErtConfig, lint_file
 from ert.logging import LOGGING_CONFIG
@@ -32,11 +34,11 @@ from ert.mode_definitions import (
     WORKFLOW_MODE,
 )
 from ert.namespace import Namespace
-from ert.plugins import ErtPluginContext, ErtRuntimePlugins
+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.shared.storage.command import add_parser_options as ert_api_add_parser_options
-from ert.storage import ErtStorageException
+from ert.storage import ErtStorageException, ErtStoragePermissionError
 from ert.trace import trace, tracer
 from ert.validation import (
     IntegerArgument,
@@ -68,8 +70,7 @@ def run_webviz_ert(args: Namespace, _: ErtRuntimePlugins | None = None) -> None:
         ) from err
 
     kwargs: dict[str, Any] = {"verbose": args.verbose}
-    with ErtPluginContext() as runtime_plugins:
-        ert_config = ErtConfig.with_plugins(runtime_plugins).from_file(args.config)
+    ert_config = ErtConfig.with_plugins(get_site_plugins()).from_file(args.config)
 
     os.chdir(ert_config.config_path)
     ens_path = ert_config.ens_path
@@ -636,25 +637,24 @@ def main() -> None:
 
     os.environ["ERT_LOG_DIR"] = log_dir
 
-    with open(LOGGING_CONFIG, encoding="utf-8") as conf_file:
-        config_dict = yaml.safe_load(conf_file)
-        for handler_name, handler_config in config_dict["handlers"].items():
-            if handler_name == "file":
-                handler_config["filename"] = "ert-log.txt"
-            if "ert.logging.TimestampedFileHandler" in handler_config.values():
-                handler_config["config_filename"] = args.config
-        try:
-            logging.config.dictConfig(config_dict)
-        except ValueError as err:
-            if "handler 'file'" in str(err):
-                exit_msg = (
-                    f"Could not configure log handler for files. "
-                    f"Check if you have write-access to the logs-directory ({log_dir})."
-                )
-            else:
-                exit_msg = str(err)
-            os.environ.pop("ERT_LOG_DIR")
-            sys.exit(exit_msg)
+    config_dict = yaml.safe_load(Path(LOGGING_CONFIG).read_text(encoding="utf-8"))
+    for handler_name, handler_config in config_dict["handlers"].items():
+        if handler_name == "file":
+            handler_config["filename"] = "ert-log.txt"
+        if "ert.logging.TimestampedFileHandler" in handler_config.values():
+            handler_config["config_filename"] = args.config
+    try:
+        logging.config.dictConfig(config_dict)
+    except ValueError as err:
+        if "handler 'file'" in str(err):
+            exit_msg = (
+                f"Could not configure log handler for files. "
+                f"Check if you have write-access to the logs-directory ({log_dir})."
+            )
+        else:
+            exit_msg = str(err)
+        os.environ.pop("ERT_LOG_DIR")
+        sys.exit(exit_msg)
 
     logger = logging.getLogger(__name__)
     if args.verbose:
@@ -663,9 +663,14 @@ def main() -> None:
         handler.setLevel(logging.INFO)
         root_logger.addHandler(handler)
     try:
-        with ErtPluginContext(logger=logging.getLogger()) as runtime_plugins:
+        site_plugins = get_site_plugins()
+        setup_site_logging(logging.getLogger())
+        with use_runtime_plugins(site_plugins):
             logger.info(f"Running ert with {args} in {os.getcwd()}")
-            args.func(args, runtime_plugins)
+            args.func(args, site_plugins)
+    except ErtStoragePermissionError as err:
+        logger.error(str(err))
+        sys.exit(str(err))
     except (ErtCliError, ErtStorageException) as err:
         span.set_status(Status(StatusCode.ERROR))
         span.record_exception(err)

ert/base_model_context.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 
 @contextmanager
-def init_context(value: ErtRuntimePlugins) -> Iterator[None]:
+def use_runtime_plugins(value: ErtRuntimePlugins) -> Iterator[None]:
     token = init_context_var.set(value)  # type: ignore
     try:
         yield

ert/cli/main.py

@@ -10,6 +10,7 @@ from collections import Counter
 from typing import TextIO
 
 from _ert.threading import ErtThread
+from ert.base_model_context import use_runtime_plugins
 from ert.cli.monitor import Monitor
 from ert.cli.workflow import execute_workflow
 from ert.config import ErtConfig, QueueSystem
@@ -23,7 +24,7 @@ from ert.mode_definitions import (
     WORKFLOW_MODE,
 )
 from ert.namespace import Namespace
-from ert.plugins import ErtPluginContext, ErtRuntimePlugins
+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
@@ -45,10 +46,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
     if runtime_plugins is not None:
         ert_config = ErtConfig.with_plugins(runtime_plugins).from_file(args.config)
     else:
-        with ErtPluginContext() as default_runtime_plugins:
-            ert_config = ErtConfig.with_plugins(default_runtime_plugins).from_file(
-                args.config
-            )
+        ert_config = ErtConfig.with_plugins(get_site_plugins()).from_file(args.config)
 
     local_storage_set_ert_config(ert_config)
     counter_fm_steps = Counter(fms.name for fms in ert_config.forward_model_steps)
@@ -96,7 +94,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
 
     status_queue: queue.SimpleQueue[StatusEvents] = queue.SimpleQueue()
     try:
-        with ErtPluginContext():
+        with use_runtime_plugins(get_site_plugins()):
             model = create_model(
                 ert_config,
                 args,

ert/config/__init__.py

@@ -63,6 +63,7 @@ from .workflow_fixtures import (
     fixtures_per_hook,
 )
 from .workflow_job import (
+    BaseErtScriptWorkflow,
     ErtScriptWorkflow,
     ExecutableWorkflow,
     WorkflowJob,
@@ -72,6 +73,7 @@ from .workflow_job import (
 __all__ = [
     "AnalysisConfig",
     "AnalysisModule",
+    "BaseErtScriptWorkflow",
     "ConfigValidationError",
     "ConfigWarning",
     "DataSource",

ert/config/_create_observation_dataframes.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING, Any, assert_never
 
 import numpy as np
 import polars as pl
+from resfo_utilities import history_key
 
-from ert.summary_key_type import history_key
 from ert.validation import rangestring_to_list
 
 from ._observations import (