changing name of argument from verbose to return_inputs

Author: djarecka

pydra/engine/core.py

@@ -532,17 +532,17 @@ def done(self):
                 return True
         return False
 
-    def _combined_output(self, verbose=False):
+    def _combined_output(self, return_inputs=False):
         combined_results = []
         for (gr, ind_l) in self.state.final_combined_ind_mapping.items():
             combined_results_gr = []
             for ind in ind_l:
                 result = load_result(self.checksum_states(ind), self.cache_locations)
                 if result is None:
                     return None
-                if verbose is True or verbose == "val":
+                if return_inputs is True or return_inputs == "val":
                     result = (self.state.states_val[ind], result)
-                elif verbose == "ind":
+                elif return_inputs == "ind":
                     result = (self.state.states_ind[ind], result)
                 combined_results_gr.append(result)
             combined_results.append(combined_results_gr)
@@ -552,15 +552,15 @@ def _combined_output(self, verbose=False):
         else:
             return combined_results
 
-    def result(self, state_index=None, verbose=False):
+    def result(self, state_index=None, return_inputs=False):
         """
         Retrieve the outcomes of this particular task.
 
         Parameters
         ----------
         state_index : :obj: `int`
             index of the element for task with splitter and multiple states
-        verbose : :obj: `bool`, :obj:`str`
+        return_inputs : :obj: `bool`, :obj:`str`
             if True or "val" result is returned together with values of the input fields,
             if "ind" result is returned together with indices of the input fields
 
@@ -575,29 +575,31 @@ def result(self, state_index=None, verbose=False):
             if state_index is None:
                 # if state_index=None, collecting all results
                 if self.state.combiner:
-                    return self._combined_output(verbose=verbose)
+                    return self._combined_output(return_inputs=return_inputs)
                 else:
                     results = []
                     for checksum in self.checksum_states():
                         result = load_result(checksum, self.cache_locations)
                         if result is None:
                             return None
                         results.append(result)
-                    if verbose is True or verbose == "val":
+                    if return_inputs is True or return_inputs == "val":
                         return list(zip(self.state.states_val, results))
-                    elif verbose == "ind":
+                    elif return_inputs == "ind":
                         return list(zip(self.state.states_ind, results))
                     else:
                         return results
             else:  # state_index is not None
                 if self.state.combiner:
-                    return self._combined_output(verbose=verbose)[state_index]
+                    return self._combined_output(return_inputs=return_inputs)[
+                        state_index
+                    ]
                 result = load_result(
                     self.checksum_states(state_index), self.cache_locations
                 )
-                if verbose is True or verbose == "val":
+                if return_inputs is True or return_inputs == "val":
                     return (self.state.states_val[state_index], result)
-                elif verbose == "ind":
+                elif return_inputs == "ind":
                     return (self.state.states_ind[state_index], result)
                 else:
                     return result
@@ -606,13 +608,13 @@ def result(self, state_index=None, verbose=False):
                 raise ValueError("Task does not have a state")
             checksum = self.checksum
             result = load_result(checksum, self.cache_locations)
-            if verbose is True or verbose == "val":
+            if return_inputs is True or return_inputs == "val":
                 inputs_val = {
                     f"{self.name}.{inp}": getattr(self.inputs, inp)
                     for inp in self.input_names
                 }
                 return (inputs_val, result)
-            elif verbose == "ind":
+            elif return_inputs == "ind":
                 inputs_ind = {f"{self.name}.{inp}": None for inp in self.input_names}
                 return (inputs_ind, result)
             else:

pydra/engine/tests/test_node_task.py

@@ -368,15 +368,15 @@ def test_task_nostate_1(plugin):
     # checking the results
     results = nn.result()
     assert results.output.out == 5
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either is return_inputs is True, or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = nn.result(verbose=True)
-    results_verb_val = nn.result(verbose="val")
+    results_verb = nn.result(return_inputs=True)
+    results_verb_val = nn.result(return_inputs="val")
     assert results_verb[0] == results_verb_val[0] == {"NA.a": 3}
     assert results_verb[1].output.out == results_verb_val[1].output.out == 5
-    # checking the verbose option verbose="ind"
+    # checking the return_inputs option return_inputs="ind"
     # it should give indices of inputs (instead of values) for each element
-    results_verb_ind = nn.result(verbose="ind")
+    results_verb_ind = nn.result(return_inputs="ind")
     assert results_verb_ind[0] == {"NA.a": None}
     assert results_verb_ind[1].output.out == 5
 
@@ -722,17 +722,17 @@ def test_task_state_1(plugin):
     for i, res in enumerate(expected):
         assert results[i].output.out == res[1]
 
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either return_inputs is True or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = nn.result(verbose=True)
-    results_verb_val = nn.result(verbose="val")
+    results_verb = nn.result(return_inputs=True)
+    results_verb_val = nn.result(return_inputs="val")
     for i, res in enumerate(expected):
         assert (results_verb[i][0], results_verb[i][1].output.out) == res
         assert (results_verb_val[i][0], results_verb_val[i][1].output.out) == res
 
-    # checking the verbose option verbose="ind"
+    # checking the return_inputs option return_inputs="ind"
     # it should give indices of inputs (instead of values) for each element
-    results_verb_ind = nn.result(verbose="ind")
+    results_verb_ind = nn.result(return_inputs="ind")
     expected_ind = [({"NA.a": 0}, 5), ({"NA.a": 1}, 7)]
     for i, res in enumerate(expected_ind):
         assert (results_verb_ind[i][0], results_verb_ind[i][1].output.out) == res
@@ -815,17 +815,17 @@ def test_task_state_2(
     for i, res in enumerate(expected):
         assert results[i].output.out == res[1]
 
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either return_inputs is True or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = nn.result(verbose=True)
-    results_verb_val = nn.result(verbose="val")
+    results_verb = nn.result(return_inputs=True)
+    results_verb_val = nn.result(return_inputs="val")
     for i, res in enumerate(expected):
         assert (results_verb[i][0], results_verb[i][1].output.out) == res
         assert (results_verb_val[i][0], results_verb_val[i][1].output.out) == res
 
-    # checking the verbose option verbose="ind"
+    # checking the return_inputs option return_inputs="ind"
     # it should give indices of inputs (instead of values) for each element
-    results_verb_ind = nn.result(verbose="ind")
+    results_verb_ind = nn.result(return_inputs="ind")
     for i, res in enumerate(expected_ind):
         assert (results_verb_ind[i][0], results_verb_ind[i][1].output.out) == res
 
@@ -1040,16 +1040,16 @@ def test_task_state_comb_1(plugin):
 
     expected = [({"NA.a": 3}, 5), ({"NA.a": 5}, 7)]
     expected_ind = [({"NA.a": 0}, 5), ({"NA.a": 1}, 7)]
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either return_inputs is True or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = nn.result(verbose=True)
-    results_verb_val = nn.result(verbose="val")
+    results_verb = nn.result(return_inputs=True)
+    results_verb_val = nn.result(return_inputs="val")
     for i, res in enumerate(expected):
         assert (results_verb[i][0], results_verb[i][1].output.out) == res
         assert (results_verb_val[i][0], results_verb_val[i][1].output.out) == res
-    # checking the verbose option verbose="ind"
+    # checking the return_inputs option return_inputs="ind"
     # it should give indices of inputs (instead of values) for each element
-    results_verb_ind = nn.result(verbose="ind")
+    results_verb_ind = nn.result(return_inputs="ind")
     for i, res in enumerate(expected_ind):
         assert (results_verb_ind[i][0], results_verb_ind[i][1].output.out) == res
 
@@ -1172,9 +1172,9 @@ def test_task_state_comb_2(
 
     # checking the results
     results = nn.result()
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either return_inputs is True or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = nn.result(verbose=True)
+    results_verb = nn.result(return_inputs=True)
 
     if nn.state.splitter_rpn_final:
         for i, res in enumerate(expected):

pydra/engine/tests/test_workflow.py

@@ -592,17 +592,17 @@ def test_wf_st_3(plugin):
     for i, res in enumerate(expected):
         assert results[i].output.out == res[1]
 
-    # checking the verbose option, either verbose=True, or verbose="val",
+    # checking the return_inputs option, either return_inputs is True or "val",
     # it should give values of inputs that corresponds to the specific element
-    results_verb = wf.result(verbose=True)
-    results_verb_val = wf.result(verbose="val")
+    results_verb = wf.result(return_inputs=True)
+    results_verb_val = wf.result(return_inputs="val")
     for i, res in enumerate(expected):
         assert (results_verb[i][0], results_verb[i][1].output.out) == res
         assert (results_verb_val[i][0], results_verb_val[i][1].output.out) == res
 
-    # checking the verbose option verbose="ind"
+    # checking the return_inputs option return_inputs="ind"
     # it should give indices of inputs (instead of values) for each element
-    results_verb_ind = wf.result(verbose="ind")
+    results_verb_ind = wf.result(return_inputs="ind")
     for i, res in enumerate(expected_ind):
         assert (results_verb_ind[i][0], results_verb_ind[i][1].output.out) == res