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

ert/ensemble_evaluator/evaluator.py

@@ -6,6 +6,8 @@ import threading
 import traceback
 from collections import defaultdict
 from collections.abc import Awaitable, Callable, Iterable, Sequence
+from dataclasses import dataclass
+from math import ceil
 from typing import Any, cast, get_args
 
 import zmq.asyncio
@@ -15,6 +17,7 @@ from _ert.events import (
     EESnapshot,
     EESnapshotUpdate,
     EnsembleCancelled,
+    EnsembleEvaluationWarning,
     EnsembleFailed,
     EnsembleStarted,
     EnsembleSucceeded,
@@ -49,6 +52,13 @@ from .state import (
     ENSEMBLE_STATE_STOPPED,
 )
 
+
+@dataclass(order=True)
+class ParallelismViolation:
+    amount: float = 0
+    message: str = ""
+
+
 logger = logging.getLogger(__name__)
 
 EVENT_HANDLER = Callable[[list[SnapshotInputEvent]], Awaitable[None]]
@@ -68,6 +78,13 @@ class EventSentinel:
 
 class EnsembleEvaluator:
     BATCHING_INTERVAL = 0.5
+    DEFAULT_SLEEP_PERIOD = 0.1
+
+    # These properties help us determine whether the user
+    # has misconfigured NUM_CPU in their config.
+    ALLOWED_CPU_OVERSPENDING = 1.05
+    MINIMUM_WALLTIME_SECONDS = 30  # Information is only polled every 5 sec
+    CPU_OVERSPENDING_WARNING_THRESHOLD = 1.50
 
     def __init__(
         self,
@@ -123,6 +140,7 @@ class EnsembleEvaluator:
             submit_sleep=self.ensemble._queue_config.submit_sleep,
             ens_id=self.ensemble.id_,
         )
+        self.max_parallelism_violation = ParallelismViolation()
 
     async def _publisher(self) -> None:
         heartbeat_interval = 0.1
@@ -145,6 +163,11 @@ class EnsembleEvaluator:
                         self._evaluation_result.set_result(True)
                     return
 
+                elif isinstance(event, EnsembleEvaluationWarning):
+                    if self._event_handler:
+                        self._event_handler(event)
+                    self._events_to_send.task_done()
+
                 elif type(event) in {
                     EESnapshot,
                     EESnapshotUpdate,
@@ -191,7 +214,7 @@ class EnsembleEvaluator:
                 await self._signal_cancel()
                 logger.debug("Run model cancelled - during evaluation - cancel sent")
                 self._end_event.clear()
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
 
     async def _send_terminate_message_to_dispatchers(self) -> None:
         event = TERMINATE_MSG
@@ -244,6 +267,7 @@ class EnsembleEvaluator:
                 event_handler[event_type] = func
 
         set_event_handler(set(get_args(FMEvent | RealizationEvent)), self._fm_handler)
+        set_event_handler({EnsembleEvaluationWarning}, self._warning_event_handler)
         set_event_handler({EnsembleStarted}, self._started_handler)
         set_event_handler({EnsembleSucceeded}, self._stopped_handler)
         set_event_handler({EnsembleCancelled}, self._cancelled_handler)
@@ -264,7 +288,7 @@ class EnsembleEvaluator:
                     batch.append((function, event))
                     self._events.task_done()
                 except asyncio.QueueEmpty:
-                    await asyncio.sleep(0.1)
+                    await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
                     continue
             self._complete_batch.set()
             await self._batch_processing_queue.put(batch)
@@ -274,6 +298,12 @@ class EnsembleEvaluator:
     async def _fm_handler(self, events: Sequence[FMEvent | RealizationEvent]) -> None:
         await self._append_message(self.ensemble.update_snapshot(events))
 
+    async def _warning_event_handler(
+        self, events: Sequence[EnsembleEvaluationWarning]
+    ) -> None:
+        for event in events:
+            await self._events_to_send.put(event)
+
     async def _started_handler(self, events: Sequence[EnsembleStarted]) -> None:
         if self.ensemble.status != ENSEMBLE_STATE_FAILED:
             await self._append_message(self.ensemble.update_snapshot(events))
@@ -288,11 +318,9 @@ class EnsembleEvaluator:
             memory_usage = fm_step.get(ids.MAX_MEMORY_USAGE) or "-1"
             max_memory_usage = max(int(memory_usage), max_memory_usage)
 
-            cpu_message = detect_overspent_cpu(
+            self.detect_overspent_cpu(
                 self.ensemble.reals[int(real_id)].num_cpu, real_id, fm_step
             )
-            if self.ensemble.queue_system != QueueSystem.LOCAL and cpu_message:
-                logger.warning(cpu_message)
 
         logger.info(
             "Ensemble ran with maximum memory usage for a "
@@ -368,6 +396,7 @@ class EnsembleEvaluator:
                     logger.warning(
                         "Evaluator receiver closed, no new messages are received"
                     )
+                    return  # The socket is closed, and we won't re-establish it.
                 else:
                     logger.error(f"Unexpected error when listening to messages: {e}")
             except asyncio.CancelledError:
@@ -416,7 +445,7 @@ class EnsembleEvaluator:
             while True:
                 if self._evaluation_result.done():
                     break
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
             logger.debug("Async server exiting.")
         finally:
             try:
@@ -647,27 +676,50 @@ class EnsembleEvaluator:
         else:
             await self._events.put(EnsembleCancelled(ensemble=self.ensemble.id_))
 
-
-def detect_overspent_cpu(num_cpu: int, real_id: str, fm_step: FMStepSnapshot) -> str:
-    """Produces a message warning about misconfiguration of NUM_CPU if
-    so is detected. Returns an empty string if everything is ok."""
-    allowed_overspending = 1.05
-    minimum_wallclock_time_seconds = 30  # Information is only polled every 5 sec
-
-    start_time = fm_step.get(ids.START_TIME)
-    end_time = fm_step.get(ids.END_TIME)
-    if start_time is None or end_time is None:
-        return ""
-    duration = (end_time - start_time).total_seconds()
-    if duration <= minimum_wallclock_time_seconds:
-        return ""
-    cpu_seconds = fm_step.get(ids.CPU_SECONDS) or 0.0
-    parallelization_obtained = cpu_seconds / duration
-    if parallelization_obtained > num_cpu * allowed_overspending:
-        return (
-            f"Misconfigured NUM_CPU, forward model step '{fm_step.get(ids.NAME)}' for "
-            f"realization {real_id} spent {cpu_seconds} cpu seconds "
-            f"with wall clock duration {duration:.1f} seconds, "
-            f"a factor of {parallelization_obtained:.2f}, while NUM_CPU was {num_cpu}."
+    def detect_overspent_cpu(
+        self, num_cpu: int, real_id: str, fm_step: FMStepSnapshot
+    ) -> None:
+        """Produces a message warning about misconfiguration of NUM_CPU if
+        so is detected. Returns an empty string if everything is ok."""
+        allowed_overspending = self.ALLOWED_CPU_OVERSPENDING * num_cpu
+        overspending_warning_threshold = (
+            self.CPU_OVERSPENDING_WARNING_THRESHOLD * num_cpu
         )
-    return ""
+
+        start_time = fm_step.get(ids.START_TIME)
+
+        end_time = fm_step.get(ids.END_TIME)
+        if start_time is None or end_time is None:
+            return
+
+        duration = (end_time - start_time).total_seconds()
+        if duration <= self.MINIMUM_WALLTIME_SECONDS:
+            return
+
+        cpu_seconds = fm_step.get(ids.CPU_SECONDS) or 0.0
+        parallelization_obtained = cpu_seconds / duration
+        if (
+            parallelization_obtained > allowed_overspending
+            and self.ensemble.queue_system != QueueSystem.LOCAL
+        ):
+            logger.warning(
+                f"Misconfigured NUM_CPU, forward model step '{fm_step.get(ids.NAME)}' "
+                f"for realization {real_id} spent {cpu_seconds} cpu seconds "
+                f"with wall clock duration {duration:.1f} seconds, a factor of "
+                f"{parallelization_obtained:.2f}, while NUM_CPU was {num_cpu}."
+            )
+            if parallelization_obtained > overspending_warning_threshold:
+                warning_msg = (
+                    "Overusage of CPUs detected!\n"
+                    f"Your experiment has used up to {ceil(parallelization_obtained)} "
+                    f"CPUs in step '{fm_step.get(ids.NAME)}', "
+                    f"while the Ert config has only requested {num_cpu}.\n"
+                    f"This means your experiment is consuming more CPU-resources than "
+                    f"requested and will slow down other users experiments.\n"
+                    f"We kindly ask you to set "
+                    f"NUM_CPU={ceil(parallelization_obtained)} in your Ert config."
+                )
+                self.max_parallelism_violation = max(
+                    self.max_parallelism_violation,
+                    ParallelismViolation(parallelization_obtained, warning_msg),
+                )

ert/ensemble_evaluator/event.py

@@ -1,4 +1,5 @@
 from collections.abc import Mapping
+from datetime import datetime
 from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, field_serializer, field_validator
@@ -42,6 +43,11 @@ class SnapshotUpdateEvent(_UpdateEvent):
     event_type: Literal["SnapshotUpdateEvent"] = "SnapshotUpdateEvent"
 
 
+class StartEvent(BaseModel):
+    event_type: Literal["StartEvent"] = "StartEvent"
+    timestamp: datetime
+
+
 class EndEvent(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
     event_type: Literal["EndEvent"] = "EndEvent"

ert/ensemble_evaluator/snapshot.py

@@ -12,6 +12,7 @@ from _ert.events import (
     EESnapshot,
     EESnapshotUpdate,
     EnsembleCancelled,
+    EnsembleEvaluationWarning,
     EnsembleEvent,
     EnsembleFailed,
     EnsembleStarted,
@@ -424,7 +425,8 @@ class EnsembleSnapshot:
 
         elif e_type in get_args(EnsembleEvent):
             event = cast(EnsembleEvent, event)
-            self._ensemble_state = _ENSEMBLE_TYPE_EVENT_TO_STATUS[type(event)]
+            if not isinstance(event, EnsembleEvaluationWarning):
+                self._ensemble_state = _ENSEMBLE_TYPE_EVENT_TO_STATUS[type(event)]
         elif type(event) is EESnapshotUpdate:
             self.merge_snapshot(EnsembleSnapshot.from_nested_dict(event.snapshot))
         elif type(event) is EESnapshot:

ert/ensemble_evaluator/state.py

@@ -7,6 +7,7 @@ COLOR_RUNNING: Final = (255, 255, 153)
 COLOR_UNKNOWN: Final = (128, 128, 128)
 COLOR_WAITING: Final = (164, 200, 255)
 COLOR_CANCELLED: Final = (235, 242, 246)
+COLOR_WARNING: Final = (255, 103, 0)
 
 ENSEMBLE_STATE_CANCELLED: Final = "Cancelled"
 ENSEMBLE_STATE_FAILED: Final = "Failed"

ert/field_utils/__init__.py

@@ -4,20 +4,28 @@ from .field_file_format import FieldFileFormat
 from .field_utils import (
     ErtboxParameters,
     Shape,
+    calc_rho_for_2d_grid_layer,
     calculate_ertbox_parameters,
     get_shape,
+    localization_scaling_function,
     read_field,
     read_mask,
     save_field,
+    transform_local_ellipse_angle_to_local_coords,
+    transform_positions_to_local_field_coordinates,
 )
 
 __all__ = [
     "ErtboxParameters",
     "FieldFileFormat",
     "Shape",
+    "calc_rho_for_2d_grid_layer",
     "calculate_ertbox_parameters",
     "get_shape",
+    "localization_scaling_function",
     "read_field",
     "read_mask",
     "save_field",
+    "transform_local_ellipse_angle_to_local_coords",
+    "transform_positions_to_local_field_coordinates",
 ]

ert/field_utils/field_utils.py

@@ -15,7 +15,7 @@ from .roff_io import export_roff, import_roff
 
 if TYPE_CHECKING:
     import numpy.typing as npt
-    import xtgeo  # type: ignore
+    import xtgeo
 
 _PathLike: TypeAlias = str | os.PathLike[str]
 
@@ -216,7 +216,6 @@ def calculate_ertbox_parameters(
 def read_field(
     field_path: _PathLike,
     field_name: str,
-    mask: npt.NDArray[np.bool_],
     shape: Shape,
 ) -> np.ma.MaskedArray[Any, np.dtype[np.float32]]:
     path = Path(field_path)
@@ -239,7 +238,7 @@ def read_field(
         ext = path.suffix
         raise ValueError(f'Could not read {field_path}. Unrecognized suffix "{ext}"')
 
-    return np.ma.MaskedArray(data=values, mask=mask, fill_value=np.nan)  # type: ignore
+    return np.ma.MaskedArray(data=values, fill_value=np.nan)
 
 
 def save_field(
@@ -263,3 +262,213 @@ def save_field(
         export_grdecl(field, output_path, field_name, binary=True)
     else:
         raise ValueError(f"Cannot export, invalid file format: {file_format}")
+
+
+def transform_positions_to_local_field_coordinates(
+    coordsys_origin: tuple[float, float],
+    coordsys_rotation_angle: float,
+    utmx: npt.NDArray[np.float64],
+    utmy: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """Calculates coordinate transformation from global to local coordinates.
+
+    Args:
+        coordys_origin: (x,y) coordinate of local coordinate
+        origin in global coordinates.
+        coordsys_rotation_angle: Angle for how much the local x-axis is rotated
+        anti-clockwise relative to the global x-axis in degrees.
+        utmx: vector of x-coordinates in global coordinates.
+        utmy: vector of y-coordinates in global coordinates.
+
+    Returns:
+        First vector is local x-coordinates and second vector is local y-coordinates.
+    """
+    # Translate
+    x1 = utmx - coordsys_origin[0]
+    y1 = utmy - coordsys_origin[1]
+    # Rotate
+    # Input angle is the local coordinate systems rotation
+    # anticlockwise relative to global x-axis in degrees
+    rotation_of_ertbox = coordsys_rotation_angle
+    rotation_angle = np.deg2rad(rotation_of_ertbox)
+    cos_theta = np.cos(rotation_angle)
+    sin_theta = np.sin(rotation_angle)
+    x2 = x1 * cos_theta + y1 * sin_theta
+    y2 = -x1 * sin_theta + y1 * cos_theta
+    return x2, y2
+
+
+def transform_local_ellipse_angle_to_local_coords(
+    coordsys_rotation_angle: float,
+    ellipse_anisotropy_angle: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate angles relative to local coordinate system.
+
+    Args:
+        coordsys_rotation_angle: Local coordinate systems rotation angle
+        relative to the global coordinate system.
+        ellipse_anisotropy_angle: Vector of input angles in global coordinates.
+
+    Returns:
+        Vector of output angles relative to the local coordinate system.
+    """
+    # Both angles measured anti-clock from global coordinate systems x-axis in degrees
+    return ellipse_anisotropy_angle - coordsys_rotation_angle
+
+
+def localization_scaling_function(
+    distances: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate scaling factor to be used as values in
+    RHO matrix in distance-based localization.
+    The scaling function implements the commonly
+    used function published by Gaspari and Cohn.
+    For input normalized distance >= 2, the value will be 0.
+
+    Args:
+        distances: Vector of values for normalized distances.
+
+    Returns:
+        Values of scaling factors for each value of input distance.
+    """
+    # "gaspari-cohn"
+    # Commonly used in distance-based localization
+    # Is exact 0 for normalized distance > 2.
+    scaling_factor = distances
+    d2 = distances**2
+    d3 = d2 * distances
+    d4 = d3 * distances
+    d5 = d4 * distances
+    s = -1 / 4 * d5 + 1 / 2 * d4 + 5 / 8 * d3 - 5 / 3 * d2 + 1
+    scaling_factor[distances <= 1] = s[distances <= 1]
+    s = (
+        1 / 12 * d5
+        - 1 / 2 * d4
+        + 5 / 8 * d3
+        + 5 / 3 * d2
+        - 5 * distances
+        + 4
+        - 2 / 3 * 1 / distances
+    )
+    scaling_factor[(distances > 1) & (distances <= 2)] = s[
+        (distances > 1) & (distances <= 2)
+    ]
+    scaling_factor[distances > 2] = 0.0
+
+    return scaling_factor
+
+
+def calc_rho_for_2d_grid_layer(
+    nx: int,
+    ny: int,
+    xinc: float,
+    yinc: float,
+    obs_xpos: npt.NDArray[np.float64],
+    obs_ypos: npt.NDArray[np.float64],
+    obs_main_range: npt.NDArray[np.float64],
+    obs_perp_range: npt.NDArray[np.float64],
+    obs_anisotropy_angle: npt.NDArray[np.float64],
+    right_handed_grid_indexing: bool = True,
+) -> npt.NDArray[np.float64]:
+    """Calculate scaling values (RHO matrix elements) for a set of observations
+    with associated localization ellipse. The method will first
+    calculate the distances from each observation position to each grid cell
+    center point of all grid cells for a 2D grid.
+    The localization method will only consider lateral distances, and it is
+    therefore sufficient to calculate the distances in 2D.
+    All input observation positions are in the local grid coordinate system
+    to simplify the calculation of the distances.
+
+    The position: xpos[n], ypos[n] and
+    localization ellipse defined by obs_main_range[n],obs_perp_range[n],
+    obs_anisotropy_angle[n]) refers to observation[n].
+
+    The distance between an observation with index n and a grid cell (i,j) is
+    d[m,n] = dist((xpos_obs[n],ypos_obs[n]),(xpos_field[i,j],ypos_field[i,j]))
+
+    RHO[[m,n] = scaling(d)
+    where m = j + i * ny for left-handed grid index origo and
+          m = (ny - j - 1) + i * ny for right-handed grid index origo
+    Note that since d[m,n] does only depend on observation index n and
+    grid cell index (i,j). The values for RHO is
+    calculated for the combination ((i,j), n) and this covers
+    one grid layer in ertbox grid or a 2D surface grid.
+
+    Args:
+        nx: Number of grid cells in x-direction of local coordinate system.
+        ny: Number of grid cells in y-direction of local coordinate system.
+        xinc: Grid cell size in x-direction.
+        yinc: Grid cell size in y-direction.
+        obs_xpos: Observations x coordinates in local coordinates
+        obs_ypos: Observatiopns y coordinates in local coordinates
+        obs_main_range: Localization ellipse first range
+        obs_perp_range: Localization ellipse second range
+        obs_anisotropy_angle: Localization ellipse orientation relative
+        to local coordinate system in degrees
+
+    Returns:
+        Rho matrix values for one layer of the 3D ertbox grid or for a 2D surface grid.
+    """
+    # Center points of each grid cell in field parameter grid
+    x_local = (np.arange(nx, dtype=np.float64) + 0.5) * xinc
+    if right_handed_grid_indexing:
+        # y coordinate descreases from max to min
+        y_local = (np.arange(ny - 1, -1, -1, dtype=np.float64) + 0.5) * yinc
+    else:
+        # y coordinate increases from min to max
+        y_local = (np.arange(ny, dtype=np.float64) + 0.5) * yinc
+    mesh_x_coord, mesh_y_coord = np.meshgrid(x_local, y_local, indexing="ij")
+
+    # Number of observations
+    nobs = len(obs_xpos)
+    assert nobs == len(obs_ypos), (
+        "Number of coordinates must match number of observations"
+    )
+    assert nobs == len(obs_anisotropy_angle), (
+        "Number of ellipse orientation angles must match number of observations"
+    )
+    assert nobs == len(obs_main_range), (
+        "Number of ellipse main range values must match number of observations"
+    )
+    assert nobs == len(obs_perp_range), (
+        "Number of ellipse second range values must match number of observations"
+    )
+    assert np.all(obs_main_range > 0.0), (
+        "All range values for all observations must be positive"
+    )
+    assert np.all(obs_perp_range > 0.0), (
+        "All range values for all observations must be positive"
+    )
+
+    # Expand grid coordinates to match observations
+    mesh_x_coord_flat = mesh_x_coord.flatten()[:, np.newaxis]  # (nx * ny, 1)
+    mesh_y_coord_flat = mesh_y_coord.flatten()[:, np.newaxis]  # (nx * ny, 1)
+
+    # Observation coordinates and parameters
+    obs_xpos = obs_xpos[np.newaxis, :]  # (1, nobs)
+    obs_ypos = obs_ypos[np.newaxis, :]  # (1, nobs)
+    obs_main_range = obs_main_range[np.newaxis, :]  # (1, nobs)
+    obs_perp_range = obs_perp_range[np.newaxis, :]  # (1, nobs)
+    obs_anisotropy_angle = obs_anisotropy_angle[np.newaxis, :]  # (1, nobs)
+
+    # Compute displacement between grid points and observations
+    dX = mesh_x_coord_flat - obs_xpos  # (nx * ny, nobs)
+    dY = mesh_y_coord_flat - obs_ypos  # (nx * ny, nobs)
+
+    # Compute rotation parameters
+    rotation = np.deg2rad(obs_anisotropy_angle)
+    cos_angle = np.cos(rotation)  # (1, nobs)
+    sin_angle = np.sin(rotation)  # (1, nobs)
+
+    # Rotate and scale displacements to local coordinate system defined
+    # by the two half axes of the influence ellipse. First coordinate (local x) is in
+    # direction defined by anisotropy angle and local y is perpendicular to that.
+    # Scale the distance by the ranges to get a normalized distance
+    # (with value 1 at the edge of the ellipse)
+    dX_ellipse = (dX * cos_angle + dY * sin_angle) / obs_main_range  # (nx * ny, nobs)
+    dY_ellipse = (-dX * sin_angle + dY * cos_angle) / obs_perp_range  # (nx * ny, nobs)
+
+    # Compute distances in the elliptical coordinate system
+    distances = np.hypot(dX_ellipse, dY_ellipse)  # (nx * ny, nobs)
+    # Apply the scaling function
+    return localization_scaling_function(distances).reshape((nx, ny, nobs))

ert/field_utils/roff_io.py

@@ -23,7 +23,7 @@ def export_roff(
     binary: bool,
 ) -> None:
     dimensions = data.shape
-    data = np.flip(data, -1).ravel()  # type: ignore
+    data = np.flip(data, -1).ravel()
     data = data.astype(np.float32).filled(RMS_UNDEFINED_FLOAT)  # type: ignore
     if not np.isfinite(data).all():
         raise ValueError(

ert/gui/__init__.py

@@ -20,12 +20,15 @@ else:
 
 def is_high_contrast_mode() -> bool:
     app = cast(QWidget, QApplication.instance())
-    return app.palette().color(QPalette.ColorRole.Window).lightness() > 245
+    return (
+        app is not None
+        and app.palette().color(QPalette.ColorRole.Window).lightness() > 245
+    )
 
 
 def is_dark_mode() -> bool:
     app = cast(QWidget, QApplication.instance())
-    return app.palette().base().color().value() < 70
+    return app is not None and app.palette().base().color().value() < 70
 
 
 __version__ = ert.shared.__version__

ert/gui/ertnotifier.py

@@ -74,7 +74,7 @@ class ErtNotifier(QObject):
     @Slot()
     def emitErtChange(self) -> None:
         if self._storage is not None:
-            self._storage.refresh()
+            self._storage.reload()
 
         self.ertChanged.emit()
 

ert/gui/ertwidgets/__init__.py

@@ -1,31 +1,34 @@
-# isort: skip_file
+from collections.abc import Callable
+from typing import Any
+
 from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QCursor
 from PyQt6.QtWidgets import QApplication
-from typing import Any
-from collections.abc import Callable
-
 
-from .closabledialog import ClosableDialog
 from .analysismoduleedit import AnalysisModuleEdit
-from .searchbox import SearchBox
-from .ensembleselector import EnsembleSelector
 from .checklist import CheckList
-from .stringbox import StringBox
-from .textbox import TextBox
-from .listeditbox import ListEditBox
+from .closabledialog import ClosableDialog
+from .copy_button import CopyButton
+from .copyablelabel import CopyableLabel
+from .create_experiment_dialog import CreateExperimentDialog
 from .customdialog import CustomDialog
-from .pathchooser import PathChooser
+from .ensembleselector import EnsembleSelector
+from .listeditbox import ListEditBox
 from .models import (
-    TextModel,
     ActiveRealizationsModel,
+    ErtSummary,
+    PathModel,
+    SelectableListModel,
     TargetEnsembleModel,
+    TextModel,
     ValueModel,
-    SelectableListModel,
-    PathModel,
 )
-from .copyablelabel import CopyableLabel
-from .copy_button import CopyButton
+from .parameterviewer import get_parameters_button
+from .pathchooser import PathChooser
+from .searchbox import SearchBox
+from .stringbox import StringBox
+from .suggestor import Suggestor
+from .textbox import TextBox
 
 
 def showWaitCursorWhileWaiting(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -49,17 +52,21 @@ __all__ = [
     "ClosableDialog",
     "CopyButton",
     "CopyableLabel",
+    "CreateExperimentDialog",
     "CustomDialog",
     "EnsembleSelector",
+    "ErtSummary",
     "ListEditBox",
     "PathChooser",
     "PathModel",
     "SearchBox",
     "SelectableListModel",
     "StringBox",
+    "Suggestor",
     "TargetEnsembleModel",
     "TextBox",
     "TextModel",
     "ValueModel",
+    "get_parameters_button",
     "showWaitCursorWhileWaiting",
 ]

ert/gui/ertwidgets/analysismoduleedit.py

@@ -6,8 +6,8 @@ from PyQt6.QtCore import QMargins, Qt
 from PyQt6.QtGui import QIcon
 from PyQt6.QtWidgets import QHBoxLayout, QToolButton, QWidget
 
-from ert.gui.ertwidgets import ClosableDialog
-from ert.gui.ertwidgets.analysismodulevariablespanel import AnalysisModuleVariablesPanel
+from .analysismodulevariablespanel import AnalysisModuleVariablesPanel
+from .closabledialog import ClosableDialog
 
 if TYPE_CHECKING:
     from ert.config import AnalysisModule

ert/gui/ertwidgets/checklist.py

@@ -16,7 +16,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.gui.ertwidgets import SearchBox
+from .searchbox import SearchBox
 
 if TYPE_CHECKING:
     from .models.selectable_list_model import SelectableListModel

ert/gui/ertwidgets/create_experiment_dialog.py

@@ -9,9 +9,11 @@ from PyQt6.QtWidgets import (
 )
 
 from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.ertwidgets import StringBox, TextModel, ValueModel
 from ert.validation import ExperimentValidation, IntegerArgument, ProperNameArgument
 
+from .models import TextModel, ValueModel
+from .stringbox import StringBox
+
 
 class CreateExperimentDialog(QDialog):
     onDone = Signal(str, str, int)

ert/gui/ertwidgets/ensembleselector.py

@@ -9,11 +9,11 @@ from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtWidgets import QComboBox
 
+from ert.config import ErrorInfo
 from ert.gui.ertnotifier import ErtNotifier
 from ert.storage import RealizationStorageState
 
-from ...config import ErrorInfo
-from ..suggestor import Suggestor
+from .suggestor import Suggestor
 
 if TYPE_CHECKING:
     from ert.storage import Ensemble