Add kwargs support for workflow invocations

Author: yngve-sk

src/ert/config/ert_script.py

@@ -8,7 +8,7 @@
 import warnings
 from abc import abstractmethod
 from collections.abc import Callable
-from types import MappingProxyType, ModuleType
+from types import ModuleType
 from typing import TYPE_CHECKING, Any, TypeAlias
 
 from typing_extensions import deprecated
@@ -115,24 +115,48 @@ def initializeAndRun(
         argument_types: list[type[Any]],
         argument_values: list[str],
         fixtures: dict[str, Any] | None = None,
+        **kwargs: dict[str, Any],
     ) -> Any:
         fixtures = {} if fixtures is None else fixtures
-        arguments = []
+        workflow_args = []
         for index, arg_value in enumerate(argument_values):
             arg_type = argument_types[index] if index < len(argument_types) else str
 
             if arg_value is not None:
-                arguments.append(arg_type(arg_value))
+                workflow_args.append(arg_type(arg_value))
             else:
-                arguments.append(None)
-        fixtures["workflow_args"] = arguments
+                workflow_args.append(None)
+        fixtures["workflow_args"] = workflow_args
+
+        fixture_args = []
+        all_func_args = inspect.signature(self.run).parameters
+        is_using_wf_args_fixture = "workflow_args" in all_func_args
+
         try:
-            func_args = inspect.signature(self.run).parameters
+            if not is_using_wf_args_fixture:
+                fixture_or_kw_arguments = list(all_func_args)[len(workflow_args) :]
+            else:
+                fixture_or_kw_arguments = list(all_func_args)
+
+            func_args = {k: all_func_args[k] for k in fixture_or_kw_arguments}
+
+            kwargs_defaults = {
+                k: v.default
+                for k, v in func_args.items()
+                if k not in fixtures
+                and v.kind != v.VAR_POSITIONAL
+                and not str(v).startswith("*")
+                and v.default != v.empty
+            }
+            use_kwargs = {
+                k: (kwargs or {}).get(k, default_value)
+                for k, default_value in ({**kwargs_defaults, **kwargs}).items()
+            }
             # If the user has specified *args, we skip injecting fixtures, and just
             # pass the user configured arguments
             if not any(p.kind == p.VAR_POSITIONAL for p in func_args.values()):
                 try:
-                    arguments = self.insert_fixtures(func_args, fixtures)
+                    fixture_args = self.insert_fixtures(func_args, fixtures, use_kwargs)
                 except ValueError as e:
                     # This is here for backwards compatibility, the user does not have *argv
                     # but positional arguments. Can not be mixed with using fixtures.
@@ -143,7 +167,20 @@ def initializeAndRun(
             self._ert = fixtures.get("ert_config")
             self._ensemble = fixtures.get("ensemble")
             self._storage = fixtures.get("storage")
-            return self.run(*arguments)
+
+            positional_args = (
+                fixture_args
+                if is_using_wf_args_fixture
+                else [*workflow_args, *fixture_args]
+            )
+            if not positional_args and not use_kwargs:
+                return self.run()
+            elif positional_args and not use_kwargs:
+                return self.run(*positional_args)
+            elif not positional_args and use_kwargs:
+                return self.run(**use_kwargs)
+            else:
+                return self.run(*positional_args, **use_kwargs)
         except AttributeError as e:
             error_msg = str(e)
             if not hasattr(self, "run"):
@@ -169,20 +206,22 @@ def initializeAndRun(
 
     def insert_fixtures(
         self,
-        func_args: MappingProxyType[str, inspect.Parameter],
+        func_args: dict[str, inspect.Parameter],
         fixtures: dict[str, Fixtures],
+        kwargs: dict[str, Any],
     ) -> list[Any]:
         arguments = []
         errors = []
         for val in func_args:
             if val in fixtures:
                 arguments.append(fixtures[val])
-            else:
+            elif val not in kwargs:
                 errors.append(val)
         if errors:
+            kwargs_str = ",".join(f"{k}='{v}'" for k, v in kwargs.items())
             raise ValueError(
                 f"Plugin: {self.__class__.__name__} misconfigured, arguments: {errors} "
-                f"not found in fixtures: {list(fixtures)}"
+                f"not found in fixtures: {list(fixtures)} or kwargs {kwargs_str}"
             )
         return arguments
 

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

@@ -42,7 +42,7 @@ def getArguments(self, fixtures: dict[str, Any]) -> list[Any]:
         script = self.__loadPlugin()
         fixtures["parent"] = self.__parent_window
         func_args = inspect.signature(script.getArguments).parameters
-        arguments = script.insert_fixtures(func_args, fixtures)
+        arguments = script.insert_fixtures(dict(func_args), fixtures, {})
 
         # Part of deprecation
         script._ert = fixtures.get("ert_config")

src/ert/libres_facade.py

@@ -210,6 +210,7 @@ def run_ertscript(  # type: ignore
         storage: Storage,
         ensemble: Ensemble,
         *args: Any,
+        **kwargs: dict[str, Any],
     ) -> Any:
         warnings.warn(
             "run_ertscript is deprecated, use the workflow runner",
@@ -225,6 +226,7 @@ def run_ertscript(  # type: ignore
                 "storage": storage,
                 "config_file": self.config.user_config_file,
             },
+            **kwargs,
         )
 
     @classmethod

src/ert/workflow_runner.py

@@ -57,7 +57,7 @@ def run(
         else:
             raise UserWarning("Unknown script type!")
         result = self.__script.initializeAndRun(  # type: ignore
-            self.job.argument_types(), arguments, fixtures=fixtures
+            self.job.argument_types(), arguments, fixtures
         )
         self.__running = False
 

tests/ert/unit_tests/config/test_ert_plugin.py

@@ -89,13 +89,38 @@ def run(self, arg_1, ert_script, fixture_2, arg_2="something"):
     fixture2_mock = MagicMock()
     with caplog.at_level(logging.WARNING):
         plugin.initializeAndRun(
-            [], [1, 2], {"ert_script": fixture_mock, "fixture_2": fixture2_mock}
+            [], [], {"ert_script": fixture_mock, "fixture_2": fixture2_mock}
         )
 
     assert plugin.hasFailed()
     log = "\n".join(caplog.messages)
     assert "FixturePlugin misconfigured" in log
-    assert "['arg_1', 'arg_2'] not found in fixtures" in log
+    assert ("arguments: ['arg_1'] not found in fixtures") in log
+
+
+def test_plugin_with_mixed_arguments(caplog):
+    fixture_mock = MagicMock()
+    fixture2_mock = MagicMock()
+
+    class FixturePlugin(ErtPlugin):
+        def run(self, arg_0, arg_1, ert_script, fixture_2, arg_2="something"):
+            nonlocal fixture_mock
+            nonlocal fixture2_mock
+
+            assert arg_0 == "1"
+            assert arg_1 == "2"
+            assert ert_script == fixture_mock
+            assert fixture_2 == fixture2_mock
+            assert arg_2 == "something else"
+
+    plugin = FixturePlugin()
+
+    plugin.initializeAndRun(
+        [],
+        [1, 2],
+        {"ert_script": fixture_mock, "fixture_2": fixture2_mock},
+        arg_2="something_else",
+    )
 
 
 def test_plugin_with_fixtures_and_enough_arguments():
@@ -111,17 +136,27 @@ def run(self, workflow_args, ert_script):
     )
 
 
+def test_plugin_with_fixtures_and_enough_arguments_positional():
+    class FixturePlugin(ErtPlugin):
+        def run(self, a, b, c, ert_script):
+            return ([a, b, c], ert_script)
+
+    plugin = FixturePlugin()
+    fixture_mock = MagicMock()
+    assert plugin.initializeAndRun([], [1, 2, 3], {"ert_script": fixture_mock}) == (
+        ["1", "2", "3"],
+        fixture_mock,
+    )
+
+
 def test_plugin_with_default_arguments(capsys):
     class FixturePlugin(ErtPlugin):
         def run(self, ert_script=None):
             return ert_script
 
     plugin = FixturePlugin()
     fixture_mock = MagicMock()
-    assert (
-        plugin.initializeAndRun([], [1, 2], {"ert_script": fixture_mock})
-        == fixture_mock
-    )
+    assert plugin.initializeAndRun([], [], {"ert_script": fixture_mock}) == fixture_mock
 
 
 def test_plugin_with_args():