ert 17.1.9__py3-none-any.whl → 18.0.1__py3-none-any.whl

ert/config/everest_constraints_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 EverestConstraintsConfig(ResponseConfig):
-    @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
-        ]
-
-    type: Literal["everest_constraints"] = "everest_constraints"
-    name: str = "everest_constraints"
-    has_finalized_keys: bool = True
-
-    @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_constraints"
-
-    @property
-    def primary_key(self) -> list[str]:
-        return []
-
-
-responses_index.add_response_type(EverestConstraintsConfig)

ert/services/storage_service.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-from collections.abc import Mapping, Sequence
-from json.decoder import JSONDecodeError
-from typing import Any
-
-import requests
-
-from ert.dark_storage.client import Client, ConnInfo
-from ert.services._base_service import BaseService, _Context, local_exec_args
-from ert.trace import get_traceparent
-
-
-class StorageService(BaseService):
-    service_name = "storage"
-
-    def __init__(
-        self,
-        exec_args: Sequence[str] = (),
-        timeout: int = 120,
-        parent_pid: int | None = None,
-        conn_info: Mapping[str, Any] | Exception | None = None,
-        project: str | None = None,
-        verbose: bool = False,
-        traceparent: str | None = "inherit_parent",
-        logging_config: str | None = None,
-    ) -> None:
-        self._url: str | None = None
-
-        exec_args = local_exec_args("storage")
-
-        exec_args.extend(["--project", str(project)])
-        if verbose:
-            exec_args.append("--verbose")
-        if logging_config:
-            exec_args.extend(["--logging-config", str(logging_config)])
-        if traceparent:
-            traceparent = (
-                get_traceparent() if traceparent == "inherit_parent" else traceparent
-            )
-            exec_args.extend(["--traceparent", str(traceparent)])
-        if parent_pid is not None:
-            exec_args.extend(["--parent_pid", str(parent_pid)])
-
-        if (
-            conn_info is not None
-            and isinstance(conn_info, Mapping)
-            and "urls" not in conn_info
-        ):
-            raise KeyError("urls not found in conn_info")
-        super().__init__(exec_args, timeout, conn_info, project)
-
-    def fetch_auth(self) -> tuple[str, Any]:
-        """
-        Returns a tuple of username and password, compatible with requests' `auth`
-        kwarg.
-
-        Blocks while the server is starting.
-        """
-        return ("__token__", self.fetch_conn_info()["authtoken"])
-
-    @classmethod
-    def init_service(cls, *args: Any, **kwargs: Any) -> _Context[StorageService]:
-        try:
-            service = cls.connect(timeout=0, project=kwargs.get("project", os.getcwd()))
-            # Check the server is up and running
-            _ = service.fetch_url()
-        except (TimeoutError, JSONDecodeError, KeyError) as e:
-            logging.getLogger(__name__).warning(
-                "Failed locating existing storage service due to "
-                f"{type(e).__name__}: {e}, starting new service"
-            )
-            return cls.start_server(*args, **kwargs)
-        except PermissionError as pe:
-            logging.getLogger(__name__).error(
-                f"{type(pe).__name__}: {pe}, cannot connect to storage service "
-                f"due to permission issues."
-            )
-            raise pe
-        return _Context(service)
-
-    def fetch_url(self) -> str:
-        """Returns the url. Blocks while the server is starting"""
-        if self._url is not None:
-            return self._url
-
-        for url in self.fetch_conn_info()["urls"]:
-            con_info = self.fetch_conn_info()
-            try:
-                resp = requests.get(
-                    f"{url}/healthcheck",
-                    auth=self.fetch_auth(),
-                    verify=con_info["cert"],
-                )
-                logging.getLogger(__name__).info(
-                    f"Connecting to {url} got status: "
-                    f"{resp.status_code}, {resp.headers}, {resp.reason}, {resp.text}"
-                )
-                if resp.status_code == 200:
-                    self._url = url
-                    return str(url)
-
-            except requests.ConnectionError as ce:
-                logging.getLogger(__name__).info(
-                    f"Could not connect to {url}, but will try something else. "
-                    f"Error: {ce}"
-                )
-        raise TimeoutError(
-            "None of the URLs provided for the ert storage server worked."
-        )
-
-    @classmethod
-    def session(cls, project: os.PathLike[str], timeout: int | None = None) -> Client:
-        """
-        Start a HTTP transaction with the server
-        """
-        inst = cls.connect(timeout=timeout, project=project)
-        info = inst.fetch_conn_info()
-        return Client(
-            conn_info=ConnInfo(
-                base_url=inst.fetch_url(),
-                auth_token=inst.fetch_auth()[1],
-                cert=info["cert"],
-            )
-        )

everest/config/sampler_config.py

@@ -1,103 +0,0 @@
-import logging
-from textwrap import dedent
-from typing import Any, Self
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-from everest.optimizer.utils import get_ropt_plugin_manager
-from everest.strings import EVEREST
-
-
-class SamplerConfig(BaseModel):
-    backend: str | None = Field(
-        default=None,
-        description=dedent(
-            """
-            [Deprecated]
-
-            The correct backend will be inferred by the method. If several backends
-            have a method named `A`, pick a specific backend `B` by putting `B/A` in
-            the `method` field.
-            """
-        ),
-    )
-    method: str = Field(
-        default="norm",
-        description=dedent(
-            """
-            The sampling method or distribution used by the sampler backend.
-
-            The set of available methods depends on the sampler backend used. By
-            default a plugin based on `scipy.stats` is used, implementing the
-            following methods:
-
-            - From Probability Distributions:
-                - `norm`: Samples from a standard normal distribution (mean 0,
-                  standard deviation 1).
-                - `truncnorm`: Samples from a truncated normal distribution
-                  (mean 0, std. dev. 1), truncated to the range `[-1, 1]`.
-                - `uniform`: Samples from a uniform distribution in the range
-                  `[-1, 1]`.
-
-            - From Quasi-Monte Carlo Sequences:
-                - `sobol`: Uses Sobol' sequences.
-                - `halton`: Uses Halton sequences.
-                - `lhs`: Uses Latin Hypercube Sampling.
-
-                Note: QMC samples are generated in the unit hypercube `[0, 1]^d`
-                and then scaled to the hypercube `[-1, 1]^d`.
-            """
-        ),
-    )
-    options: dict[str, Any] | None = Field(
-        default=None,
-        description=dedent(
-            """
-            Specifies a dict of optional parameters for the sampler backend.
-
-            This dict of values is passed unchanged to the selected method in
-            the backend.
-            """
-        ),
-    )
-    shared: bool | None = Field(
-        default=None,
-        description=dedent(
-            """
-            Whether to share perturbations between realizations.
-            """
-        ),
-    )
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="after")
-    def validate_backend_and_method(self) -> Self:
-        if self.backend is not None:
-            message = (
-                "sampler.backend is deprecated. "
-                "The correct backend will be inferred by the method. "
-                "If several backends have a method named A, you need to pick "
-                "a specific backend B by putting B/A in sampler.method."
-            )
-            print(message)
-            logging.getLogger(EVEREST).warning(message)
-
-        # Update the default for backends that are not scipy:
-        if (
-            self.backend not in {None, "scipy"}
-            and "method" not in self.model_fields_set
-        ):
-            self.method = "default"
-
-        if self.backend is not None:
-            self.method = f"{self.backend}/{self.method}"
-
-        if (
-            get_ropt_plugin_manager().get_plugin_name("sampler", f"{self.method}")
-            is None
-        ):
-            raise ValueError(f"Sampler method '{self.method}' not found")
-
-        self.backend = None
-
-        return self

everest/simulator/__init__.py

@@ -1,88 +0,0 @@
-JOB_SUCCESS = "Finished"
-JOB_WAITING = "Waiting"
-JOB_RUNNING = "Running"
-JOB_FAILURE = "Failed"
-
-
-DEFAULT_DATA_SUMMARY_KEYS = ["YEAR", "YEARS", "TCPU", "TCPUDAY", "MONTH", "DAY"]
-
-
-DEFAULT_FIELD_SUMMARY_KEYS = [
-    "FOPR",
-    "FOPT",
-    "FOIR",
-    "FOIT",
-    "FWPR",
-    "FWPT",
-    "FWIR",
-    "FWIT",
-    "FGPR",
-    "FGPT",
-    "FGIR",
-    "FGIT",
-    "FVPR",
-    "FVPT",
-    "FVIR",
-    "FVIT",
-    "FWCT",
-    "FGOR",
-    "FOIP",
-    "FOIPL",
-    "FOIPG",
-    "FWIP",
-    "FGIP",
-    "FGIPL",
-    "FGIPG",
-    "FPR",
-    "FAQR",
-    "FAQRG",
-    "FAQT",
-    "FAQTG",
-    "FWGR",
-]
-
-
-_DEFAULT_WELL_SUMMARY_KEYS = [
-    "WOPR",
-    "WOPT",
-    "WOIR",
-    "WOIT",
-    "WWPR",
-    "WWPT",
-    "WWIR",
-    "WWIT",
-    "WGPR",
-    "WGPT",
-    "WGIR",
-    "WGIT",
-    "WVPR",
-    "WVPT",
-    "WVIR",
-    "WVIT",
-    "WWCT",
-    "WGOR",
-    "WWGR",
-    "WBHP",
-    "WTHP",
-    "WPI",
-]
-
-_EXCLUDED_TARGET_KEYS = "WGOR"
-
-_DEFAULT_WELL_TARGET_SUMMARY_KEYS = [
-    well_key + "T"
-    for well_key in _DEFAULT_WELL_SUMMARY_KEYS
-    if well_key.endswith("R") and well_key not in _EXCLUDED_TARGET_KEYS
-]
-
-DEFAULT_WELL_SUMMARY_KEYS = (
-    _DEFAULT_WELL_SUMMARY_KEYS + _DEFAULT_WELL_TARGET_SUMMARY_KEYS
-)
-
-
-__all__ = [
-    "JOB_FAILURE",
-    "JOB_RUNNING",
-    "JOB_SUCCESS",
-    "JOB_WAITING",
-]

everest/simulator/everest_to_ert.py

@@ -1,51 +0,0 @@
-import itertools
-from typing import cast
-
-import everest
-from everest.config import EverestConfig
-from everest.config.forward_model_config import SummaryResults
-
-
-def extract_summary_keys(ever_config: EverestConfig) -> list[str]:
-    summary_fms = [
-        fm
-        for fm in ever_config.forward_model
-        if fm.results is not None and fm.results.type == "summary"
-    ]
-
-    if not summary_fms:
-        return []
-
-    summary_fm = summary_fms[0]
-    assert summary_fm.results is not None
-
-    smry_results = cast(SummaryResults, summary_fm.results)
-
-    requested_keys: list[str] = ["*"] if smry_results.keys == "*" else smry_results.keys
-
-    data_keys = everest.simulator.DEFAULT_DATA_SUMMARY_KEYS
-    field_keys = everest.simulator.DEFAULT_FIELD_SUMMARY_KEYS
-    well_sum_keys = everest.simulator.DEFAULT_WELL_SUMMARY_KEYS
-    deprecated_user_specified_keys = (
-        [] if ever_config.export is None else ever_config.export.keywords
-    )
-
-    wells = (
-        [
-            variable.name
-            for control in ever_config.controls
-            for variable in control.variables
-            if control.type == "well_control"
-        ]
-        if ever_config.wells is None
-        else [w.name for w in ever_config.wells]
-    )
-
-    well_keys = [
-        f"{sum_key}:{wname}"
-        for (sum_key, wname) in itertools.product(well_sum_keys, wells)
-    ]
-
-    all_keys = data_keys + field_keys + well_keys + deprecated_user_specified_keys
-
-    return list(set(all_keys + requested_keys))