WIP

src/ert/cli/workflow.py

@@ -20,7 +20,7 @@ def execute_workflow(
         msg = "Workflow {} is not in the list of available workflows"
         logger.error(msg.format(workflow_name))
         return
-    runner = WorkflowRunner(workflow, storage)
+    runner = WorkflowRunner(workflow, storage, ert_config=ert_config)
     runner.run_blocking()
     if not all(v["completed"] for v in runner.workflowReport().values()):
         logger.error(f"Workflow {workflow_name} failed!")

src/ert/config/ert_plugin.py

@@ -9,7 +9,7 @@ class CancelPluginException(Exception):
 
 
 class ErtPlugin(ErtScript, ABC):
-    def getArguments(self, parent: Any = None) -> List[Any]:
+    def getArguments(self, parent: Any = None, storage=None) -> List[Any]:
         return []
 
     def getName(self) -> str:

src/ert/config/ert_script.py

@@ -7,10 +7,7 @@
 import traceback
 from abc import abstractmethod
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type
-
-if TYPE_CHECKING:
-    from ert.storage import Ensemble, Storage
+from typing import Any, Callable, Dict, List, Optional, Type
 
 logger = logging.getLogger(__name__)
 
@@ -20,12 +17,7 @@ class ErtScript:
 
     def __init__(
         self,
-        storage: Storage,
-        ensemble: Optional[Ensemble] = None,
     ) -> None:
-        self.__storage = storage
-        self.__ensemble = ensemble
-
         self.__is_cancelled = False
         self.__failed = False
         self._stdoutdata = ""
@@ -51,18 +43,6 @@ def ert(self) -> None:
         logger.info(f"Accessing EnKFMain from workflow: {self.__class__.__name__}")
         raise NotImplementedError("The ert() function has been removed")
 
-    @property
-    def storage(self) -> Storage:
-        return self.__storage
-
-    @property
-    def ensemble(self) -> Optional[Ensemble]:
-        return self.__ensemble
-
-    @ensemble.setter
-    def ensemble(self, ensemble: Ensemble) -> None:
-        self.__ensemble = ensemble
-
     def isCancelled(self) -> bool:
         return self.__is_cancelled
 
@@ -134,7 +114,7 @@ def output_stack_trace(self, error: str = "") -> None:
     @staticmethod
     def loadScriptFromFile(
         path: str,
-    ) -> Callable[["Storage"], "ErtScript"]:
+    ) -> Callable[[], "ErtScript"]:
         module_name = f"ErtScriptModule_{ErtScript.__module_count}"
         ErtScript.__module_count += 1
 
@@ -155,7 +135,7 @@ def loadScriptFromFile(
     @staticmethod
     def __findErtScriptImplementations(
         module: ModuleType,
-    ) -> Callable[["Storage"], "ErtScript"]:
+    ) -> Callable[[], "ErtScript"]:
         result = []
         for _, member in inspect.getmembers(
             module,

src/ert/config/external_ert_script.py

@@ -3,17 +3,14 @@
 import codecs
 import sys
 from subprocess import PIPE, Popen
-from typing import TYPE_CHECKING, Any, Optional
+from typing import Any, Optional
 
 from .ert_script import ErtScript
 
-if TYPE_CHECKING:
-    from ert.storage import Storage
-
 
 class ExternalErtScript(ErtScript):
-    def __init__(self, storage: Storage, executable: str):
-        super().__init__(storage, None)
+    def __init__(self, executable: str):
+        super().__init__()
 
         self.__executable = executable
         self.__job: Optional[Popen[bytes]] = None

src/ert/gui/tools/plugins/plugin.py

@@ -21,10 +21,7 @@ def __init__(self, notifier: "ErtNotifier", workflow_job: "WorkflowJob"):
 
     def __loadPlugin(self) -> "ErtPlugin":
         script_obj = ErtScript.loadScriptFromFile(self.__workflow_job.script)
-        script = script_obj(
-            self.__notifier._storage,
-            ensemble=self.__notifier.current_ensemble,
-        )
+        script = script_obj()
         return script
 
     def getName(self) -> str:
@@ -39,7 +36,7 @@ def getArguments(self) -> List[Any]:
         If the user for example cancels in the GUI a CancelPluginException is raised.
         """
         script = self.__loadPlugin()
-        return script.getArguments(self.__parent_window)
+        return script.getArguments(self.__parent_window, self.__notifier.storage)
 
     def setParentWindow(self, parent_window):
         self.__parent_window = parent_window

src/ert/gui/tools/plugins/plugin_runner.py

@@ -16,9 +16,10 @@
 
 
 class PluginRunner:
-    def __init__(self, plugin: "Plugin", ert_config: ErtConfig):
+    def __init__(self, plugin: "Plugin", ert_config: ErtConfig, storage):
         super().__init__()
         self.ert_config = ert_config
+        self.storage = storage
         self.__plugin = plugin
 
         self.__plugin_finished_callback = lambda: None
@@ -36,11 +37,15 @@ def run(self):
             dialog.setObjectName("process_job_dialog")
 
             dialog.cancelConfirmed.connect(self.cancel)
-
+            fixtures = {
+                k: getattr(self, k)
+                for k in ["storage", "ert_config"]
+                if getattr(self, k)
+            }
             workflow_job_thread = ErtThread(
                 name="ert_gui_workflow_job_thread",
                 target=self.__runWorkflowJob,
-                args=(plugin, arguments, {"ert_config": self.ert_config}),
+                args=(plugin, arguments, fixtures),
                 daemon=True,
                 should_raise=False,
             )

src/ert/gui/tools/plugins/plugins_tool.py

@@ -26,7 +26,7 @@ def __init__(self, plugin_handler: "PluginHandler", notifier, ert_config):
 
         menu = QMenu()
         for plugin in plugin_handler:
-            plugin_runner = PluginRunner(plugin, ert_config)
+            plugin_runner = PluginRunner(plugin, ert_config, notifier.storage)
             plugin_runner.setPluginFinishedCallback(self.trigger)
 
             self.__plugins[plugin] = plugin_runner

src/ert/gui/tools/workflows/run_workflow_widget.py

@@ -126,6 +126,7 @@ def startWorkflow(self):
             workflow,
             storage=self.storage,
             ensemble=self.source_ensemble_selector.currentData(),
+            ert_config=self.config,
         )
         self._workflow_runner.run()
 

src/ert/job_queue/workflow_runner.py

@@ -7,7 +7,7 @@
 
 from typing_extensions import Self
 
-from ert.config import ErtScript, ExternalErtScript, Workflow, WorkflowJob
+from ert.config import ErtConfig, ErtScript, ExternalErtScript, Workflow, WorkflowJob
 
 if TYPE_CHECKING:
     from ert.storage import Ensemble, Storage
@@ -22,8 +22,6 @@ def __init__(self, workflow_job: WorkflowJob):
 
     def run(
         self,
-        storage: Optional[Storage] = None,
-        ensemble: Optional[Ensemble] = None,
         arguments: Optional[List[Any]] = None,
         fixtures: Optional[Dict[str, Any]] = None,
     ) -> Any:
@@ -44,15 +42,14 @@ def run(
             )
 
         if self.job.ert_script is not None:
-            self.__script = self.job.ert_script(storage, ensemble)
+            self.__script = self.job.ert_script()
             if self.job.stop_on_fail is not None:
                 self.stop_on_fail = self.job.stop_on_fail
             elif self.__script is not None:
                 self.stop_on_fail = self.__script.stop_on_fail or False
 
         elif not self.job.internal:
             self.__script = ExternalErtScript(
-                storage,  # type: ignore
                 self.job.executable,  # type: ignore
             )
 
@@ -114,10 +111,12 @@ def __init__(
         workflow: Workflow,
         storage: Optional[Storage] = None,
         ensemble: Optional[Ensemble] = None,
+        ert_config: Optional[ErtConfig] = None,
     ) -> None:
         self.__workflow = workflow
-        self._storage = storage
-        self._ensemble = ensemble
+        self.storage = storage
+        self.ensemble = ensemble
+        self.ert_config = ert_config
 
         self.__workflow_result: Optional[bool] = None
         self._workflow_executor = futures.ThreadPoolExecutor(max_workers=1)
@@ -153,13 +152,18 @@ def run_blocking(self) -> None:
         # Reset status
         self.__status = {}
         self.__running = True
+        fixtures = {
+            k: getattr(self, k)
+            for k in ["storage", "ensemble", "ert_config"]
+            if getattr(self, k)
+        }
 
         for job, args in self.__workflow:
             jobrunner = WorkflowJobRunner(job)
             self.__current_job = jobrunner
             if not self.__cancelled:
                 logger.info(f"Workflow job {jobrunner.name} starting")
-                jobrunner.run(self._storage, self._ensemble, args)
+                jobrunner.run(args, fixtures=fixtures)
                 self.__status[jobrunner.name] = {
                     "stdout": jobrunner.stdoutdata(),
                     "stderr": jobrunner.stderrdata(),

src/ert/run_models/base_run_model.py

@@ -496,7 +496,9 @@ def validate(self) -> None:
 
     def run_workflows(self, runtime, storage, ensemble):
         for workflow in self.ert_config.hooked_workflows[runtime]:
-            WorkflowRunner(workflow, storage, ensemble).run_blocking()
+            WorkflowRunner(
+                workflow, storage, ensemble, ert_config=self.ert_config
+            ).run_blocking()
 
     def _evaluate_and_postprocess(
         self,

src/ert/shared/share/ert/workflows/jobs/internal-gui/scripts/csv_export.py

@@ -83,13 +83,14 @@ def inferIterationNumber(self, ensemble_name):
     def run(
         self,
         output_file,
+        ert_config,
         ensemble_list=None,
         design_matrix_path=None,
         infer_iteration=True,
         drop_const_cols=False,
     ):
         ensembles = []
-        facade = LibresFacade(self.ert())
+        facade = LibresFacade(ert_config)
 
         if ensemble_list is not None:
             if ensemble_list.strip() == "*":

src/ert/shared/share/ert/workflows/jobs/internal-gui/scripts/gen_data_rft_export.py

@@ -106,6 +106,7 @@ def run(
         self,
         output_file,
         trajectory_path,
+        storage,
         ensemble_list=None,
         infer_iteration=True,
         drop_const_cols=False,
@@ -135,7 +136,7 @@ def run(
             ensemble_data = []
 
             try:
-                ensemble = self.storage.get_ensemble_by_name(ensemble_name)
+                ensemble = storage.get_ensemble_by_name(ensemble_name)
             except KeyError as exc:
                 raise UserWarning(
                     f"The ensemble '{ensemble_name}' does not exist!"
@@ -228,7 +229,7 @@ def run(
         )
         return export_info
 
-    def getArguments(self, parent=None):
+    def getArguments(self, parent, storage):
         description = (
             "The GEN_DATA RFT CSV export requires some information before it starts:"
         )
@@ -243,7 +244,7 @@ def getArguments(self, parent=None):
         trajectory_chooser = PathChooser(trajectory_model)
         trajectory_chooser.setObjectName("trajectory_chooser")
 
-        all_ensemble_list = [ensemble.name for ensemble in self.storage.ensembles]
+        all_ensemble_list = [ensemble.name for ensemble in storage.ensembles]
         list_edit = ListEditBox(all_ensemble_list)
         list_edit.setObjectName("list_of_ensembles")