debugging docker unittests

Author: tclose

pydra/design/shell.py

@@ -140,13 +140,28 @@ class out(Out):
         passed) or any input field name (a specific input field will be sent).
     """
 
-    callable: ty.Callable | None = None
+    callable: ty.Callable | None = attrs.field(default=None)
 
     def __attrs_post_init__(self):
         # Set type from return annotation of callable if not set
         if self.type is ty.Any and self.callable:
             self.type = ty.get_type_hints(self.callable).get("return", ty.Any)
 
+    @callable.validator
+    def _callable_validator(self, _, value):
+
+        if value:
+            if not callable(value):
+                raise ValueError(f"callable must be a function, not {value!r}")
+        elif not getattr(self, "path_template", None) and self.name not in [
+            "return_code",
+            "stdout",
+            "stderr",
+        ]:  # ShellOutputs.BASE_NAMES
+            raise ValueError(
+                "A shell output field must have either a callable or a path_template"
+            )
+
 
 @attrs.define(kw_only=True)
 class outarg(arg, Out):

pydra/engine/core.py

@@ -44,7 +44,7 @@
 )
 from .helpers_file import copy_nested_files, template_update
 from pydra.utils.messenger import AuditFlag
-from pydra.engine.environments import Environment, Native
+from pydra.engine.environments import Environment
 
 logger = logging.getLogger("pydra")
 
@@ -134,7 +134,9 @@ def __init__(
         # We save the submitter is the definition is a workflow otherwise we don't
         # so the task can be pickled
         self.submitter = submitter
-        self.environment = environment if environment is not None else Native()
+        self.environment = (
+            environment if environment is not None else submitter.environment
+        )
         self.name = name
         self.state_index = state_index
 

pydra/engine/specs.py

@@ -946,48 +946,46 @@ def _resolve_value(
 
         if not cls._required_fields_satisfied(fld, task.definition):
             return None
-        elif isinstance(fld, shell.outarg) and fld.path_template:
+        if isinstance(fld, shell.outarg) and fld.path_template:
             return template_update_single(
                 fld,
                 definition=task.definition,
                 output_dir=task.output_dir,
                 spec_type="output",
             )
-        elif fld.callable:
-            callable_ = fld.callable
-            if isinstance(fld.callable, staticmethod):
-                # In case callable is defined as a static method,
-                # retrieve the function wrapped in the descriptor.
-                callable_ = fld.callable.__func__
-            call_args = inspect.getfullargspec(callable_)
-            call_args_val = {}
-            for argnm in call_args.args:
-                if argnm == "field":
-                    call_args_val[argnm] = fld
-                elif argnm == "output_dir":
-                    call_args_val[argnm] = task.output_dir
-                elif argnm == "inputs":
-                    call_args_val[argnm] = task.inputs
-                elif argnm == "stdout":
-                    call_args_val[argnm] = task.return_values["stdout"]
-                elif argnm == "stderr":
-                    call_args_val[argnm] = task.return_values["stderr"]
-                else:
-                    try:
-                        call_args_val[argnm] = task.inputs[argnm]
-                    except KeyError as e:
-                        e.add_note(
-                            f"arguments of the callable function from {fld.name} "
-                            f"has to be in inputs or be field or output_dir, "
-                            f"but {argnm} is used"
-                        )
-                        raise
-            return callable_(**call_args_val)
-        else:
-            raise Exception(
-                f"Metadata for '{fld.name}', does not not contain any of the required fields "
-                f'("callable", "output_file_template" or "value"): {fld}.'
-            )
+        assert fld.callable, (
+            f"Output field '{fld.name}', does not not contain any of the required fields "
+            f'("callable", "output_file_template" or "value"): {fld}.'
+        )
+        callable_ = fld.callable
+        if isinstance(fld.callable, staticmethod):
+            # In case callable is defined as a static method,
+            # retrieve the function wrapped in the descriptor.
+            callable_ = fld.callable.__func__
+        call_args = inspect.getfullargspec(callable_)
+        call_args_val = {}
+        for argnm in call_args.args:
+            if argnm == "field":
+                call_args_val[argnm] = fld
+            elif argnm == "output_dir":
+                call_args_val[argnm] = task.output_dir
+            elif argnm == "inputs":
+                call_args_val[argnm] = task.inputs
+            elif argnm == "stdout":
+                call_args_val[argnm] = task.return_values["stdout"]
+            elif argnm == "stderr":
+                call_args_val[argnm] = task.return_values["stderr"]
+            else:
+                try:
+                    call_args_val[argnm] = task.inputs[argnm]
+                except KeyError as e:
+                    e.add_note(
+                        f"arguments of the callable function from {fld.name} "
+                        f"has to be in inputs or be field or output_dir, "
+                        f"but {argnm} is used"
+                    )
+                    raise
+        return callable_(**call_args_val)
 
 
 ShellOutputsType = ty.TypeVar("OutputType", bound=ShellOutputs)

pydra/engine/submitter.py

@@ -207,7 +207,9 @@ def __call__(
             output_types = {o.name: list[o.type] for o in list_fields(task_def.Outputs)}
 
             @workflow.define(outputs=output_types)
-            def Split(defn: TaskDef, output_types: dict, environment: Environment):
+            def Split(
+                defn: TaskDef, output_types: dict, environment: Environment | None
+            ):
                 node = workflow.add(defn, environment=environment, hooks=hooks)
                 return tuple(getattr(node, o) for o in output_types)
 

pydra/engine/tests/test_boutiques.py

@@ -3,7 +3,7 @@
 import attr
 import pytest
 from pydra.engine.helpers import attrs_values
-from .utils import result_no_submitter, result_submitter, no_win
+from .utils import run_no_submitter, run_submitter, no_win
 from pydra.design import workflow, boutiques, shell
 
 need_bosh_docker = pytest.mark.skipif(
@@ -22,7 +22,7 @@
 @pytest.mark.parametrize(
     "maskfile", ["test_brain.nii.gz", "test_brain", "test_brain.nii"]
 )
-@pytest.mark.parametrize("results_function", [result_no_submitter, result_submitter])
+@pytest.mark.parametrize("results_function", [run_no_submitter, run_submitter])
 def test_boutiques_1(maskfile, plugin, results_function, tmpdir, data_tests_dir):
     """simple task to run fsl.bet using BoshTask"""
     btask = boutiques.define(zenodo_id="1482743")