Adding comments

nipype/pipeline/engine/tests/test_newnode.py

@@ -34,6 +34,7 @@ def test_node_2():
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     nn = NewNode(name="NA", interface=interf_addtwo, inputs={"a": 3})
     assert nn.mapper is None
+    # adding NA to the name of the variable
     assert nn.inputs == {"NA.a": 3}
     assert nn.state._mapper is None
 
@@ -94,12 +95,13 @@ def test_node_6(plugin):
     # testing if the node runs properly
     nn.run(plugin=plugin)
 
-    # checking teh results
+    # checking the results
     expected = [({"NA.a": 3}, 5), ({"NA.a": 5}, 7)]
     # to be sure that there is the same order (not sure if node itself should keep the order)
     key_sort = list(expected[0][0].keys())
     expected.sort(key=lambda t: [t[0][key] for key in key_sort])
     nn.result["out"].sort(key=lambda t: [t[0][key] for key in key_sort])
+
     for i, res in enumerate(expected):
         assert nn.result["out"][i][0] == res[0]
         assert nn.result["out"][i][1] == res[1]
@@ -111,6 +113,7 @@ def test_node_7(plugin):
     """Node with interface, inputs and scalar mapper, running interface"""
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nn = NewNode(name="NA", interface=interf_addvar, base_dir="test_nd7_{}".format(plugin))
+    # scalar mapper
     nn.map(mapper=("a", "b"), inputs={"a": [3, 5], "b": [2, 1]})
 
     assert nn.mapper == ("NA.a", "NA.b")
@@ -120,12 +123,13 @@ def test_node_7(plugin):
     # testing if the node runs properly
     nn.run(plugin=plugin)
 
-    # checking teh results
+    # checking the results
     expected = [({"NA.a": 3, "NA.b": 2}, 5), ({"NA.a": 5, "NA.b": 1}, 6)]
     # to be sure that there is the same order (not sure if node itself should keep the order)
     key_sort = list(expected[0][0].keys())
     expected.sort(key=lambda t: [t[0][key] for key in key_sort])
     nn.result["out"].sort(key=lambda t: [t[0][key] for key in key_sort])
+
     for i, res in enumerate(expected):
         assert nn.result["out"][i][0] == res[0]
         assert nn.result["out"][i][1] == res[1]
@@ -137,6 +141,7 @@ def test_node_8(plugin):
     """Node with interface, inputs and vector mapper, running interface"""
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nn = NewNode(name="NA", interface=interf_addvar, base_dir="test_nd8_{}".format(plugin))
+    # [] for outer product
     nn.map(mapper=["a", "b"], inputs={"a": [3, 5], "b": [2, 1]})
 
     assert nn.mapper == ["NA.a", "NA.b"]
@@ -158,15 +163,17 @@ def test_node_8(plugin):
         assert nn.result["out"][i][1] == res[1]
 
 
-# tests for workflows that set mapper to node that are later added to a workflow
+# tests for workflows
 
 @python35_only
 def test_workflow_0(plugin="serial"):
     """workflow (without run) with one node with a mapper"""
     wf = NewWorkflow(name="wf0", workingdir="test_wf0_{}".format(plugin))
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
+    # defining a node with mapper and inputs first
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
     na.map(mapper="a", inputs={"a": [3, 5]})
+    # one of the way of adding nodes to the workflow
     wf.add_nodes([na])
     assert wf.nodes[0].mapper == "NA.a"
     assert (wf.nodes[0].inputs['NA.a'] == np.array([3, 5])).all()
@@ -202,9 +209,11 @@ def test_workflow_2(plugin):
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
     na.map(mapper="a", inputs={"a": [3, 5]})
 
+    # the second node does not have explicit mapper (but keeps the mapper from the NA node)
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, inputs={"b": 10}, base_dir="nb")
 
+    # adding 2 nodes and create a connection (as it is now)
     wf.add_nodes([na, nb])
     wf.connect(na, "out", nb, "a")
 
@@ -219,7 +228,8 @@ def test_workflow_2(plugin):
         assert wf.nodes[0].result["out"][i][0] == res[0]
         assert wf.nodes[0].result["out"][i][1] == res[1]
 
-
+    # results from NB keeps the "state input" from the first node
+    # two elements as in NA
     expected_B = [({"NA.a": 3, "NB.b": 10}, 15), ({"NA.a": 5, "NB.b": 10}, 17)]
     key_sort = list(expected_B[0][0].keys())
     expected_B.sort(key=lambda t: [t[0][key] for key in key_sort])
@@ -240,6 +250,7 @@ def test_workflow_2a(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
+    # explicit scalar mapper between "a" from NA and b
     nb.map(mapper=("NA.a", "b"), inputs={"b": [2, 1]})
 
     wf.add_nodes([na, nb])
@@ -257,6 +268,7 @@ def test_workflow_2a(plugin):
         assert wf.nodes[0].result["out"][i][0] == res[0]
         assert wf.nodes[0].result["out"][i][1] == res[1]
 
+    # two elements (scalar mapper)
     expected_B = [({"NA.a": 3, "NB.b": 2}, 7), ({"NA.a": 5, "NB.b": 1}, 8)]
     key_sort = list(expected_B[0][0].keys())
     expected_B.sort(key=lambda t: [t[0][key] for key in key_sort])
@@ -277,6 +289,7 @@ def test_workflow_2b(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
+    # outer mapper
     nb.map(mapper=["NA.a", "b"], inputs={"b": [2, 1]})
 
     wf.add_nodes([na, nb])
@@ -294,7 +307,7 @@ def test_workflow_2b(plugin):
         assert wf.nodes[0].result["out"][i][0] == res[0]
         assert wf.nodes[0].result["out"][i][1] == res[1]
 
-
+    # four elements (outer product)
     expected_B = [({"NA.a": 3, "NB.b": 1}, 6), ({"NA.a": 3, "NB.b": 2}, 7),
                   ({"NA.a": 5, "NB.b": 1}, 8), ({"NA.a": 5, "NB.b": 2}, 9)]
     key_sort = list(expected_B[0][0].keys())
@@ -315,7 +328,7 @@ def test_workflow_3(plugin):
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
     na.map(mapper="a", inputs={"a": [3, 5]})
-
+    # using add method (as in the Satra's example) with a node
     wf.add(na)
 
     assert wf.nodes[0].mapper == "NA.a"
@@ -337,6 +350,7 @@ def test_workflow_3a(plugin):
     wf = NewWorkflow(name="wf3a", workingdir="test_wf3a_{}".format(plugin))
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
 
+    # using the add method with an interface
     wf.add(interf_addtwo, base_dir="na", mapper="a", inputs={"a": [3, 5]}, name="NA")
 
     assert wf.nodes[0].mapper == "NA.a"
@@ -356,7 +370,7 @@ def test_workflow_3a(plugin):
 def test_workflow_3b(plugin):
     """using add (function) method"""
     wf = NewWorkflow(name="wf3b", workingdir="test_wf3b_{}".format(plugin))
-
+    # using the add method with a function
     wf.add(fun_addtwo, base_dir="na", mapper="a", inputs={"a": [3, 5]}, name="NA")
 
     assert wf.nodes[0].mapper == "NA.a"
@@ -386,9 +400,11 @@ def test_workflow_4(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
+    # explicit mapper with a variable from the previous node
+    # providing inputs with b
     nb.map(mapper=("NA.a", "b"), inputs={"b": [2, 1]})
     wf.add(nb)
-
+    # connect method as it is in the current version
     wf.connect(na, "out", nb, "a")
 
     wf.run(plugin=plugin)
@@ -422,7 +438,9 @@ def test_workflow_4a(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
+    # explicit mapper with a variable from the previous node
     nb.map(mapper=("NA.a", "b"), inputs={"b": [2, 1]})
+    # instead of "connect", using kwrg argument in the add method as in the example
     wf.add(nb, a="NA.out")
 
     wf.run(plugin=plugin)
@@ -456,6 +474,7 @@ def test_workflow_5(plugin):
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
 
     wf.add(na)
+    # using the map method after add (using mapper for the last added node as default)
     wf.map(mapper="a", inputs={"a": [3, 5]})
     wf.run(plugin=plugin)
 
@@ -498,7 +517,7 @@ def test_workflow_6(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
-
+    # using the map methods after add (using mapper for the last added nodes as default)
     wf.add(na)
     wf.map(mapper="a", inputs={"a": [3, 5]})
     wf.add(nb)
@@ -533,7 +552,7 @@ def test_workflow_6a(plugin):
 
     interf_addvar = Function_Interface(fun_addvar, ["out"])
     nb = NewNode(name="NB", interface=interf_addvar, base_dir="nb")
-
+    # using the map method after add (specifying the node)
     wf.add(na)
     wf.add(nb)
     wf.map(mapper="a", inputs={"a": [3, 5]}, node=na)
@@ -598,11 +617,13 @@ def test_workflow_6b(plugin):
 @python35_only
 def test_workflow_7(plugin):
     """using inputs for workflow and connect_workflow"""
+    # adding inputs to the workflow directly
     wf = NewWorkflow(name="wf7", inputs={"wf_a": [3, 5]}, workingdir="test_wf7_{}".format(plugin))
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
 
     wf.add(na)
+    # connecting the node with inputs from the workflow
     wf.connect_workflow(na, "wf_a","a")
     wf.map(mapper="a")
     wf.run(plugin=plugin)
@@ -620,11 +641,13 @@ def test_workflow_7(plugin):
 @python35_only
 def test_workflow_7a(plugin):
     """using inputs for workflow and connect(None...)"""
+    # adding inputs to the workflow directly
     wf = NewWorkflow(name="wf7a", inputs={"wf_a": [3, 5]}, workingdir="test_wf7a_{}".format(plugin))
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
 
     wf.add(na)
+    # if connect has None as the first arg, it is the same as connect_workflow
     wf.connect(None, "wf_a", na, "a")
     wf.map(mapper="a")
     wf.run(plugin=plugin)
@@ -645,7 +668,7 @@ def test_workflow_7b(plugin):
     wf = NewWorkflow(name="wf7b", inputs={"wf_a": [3, 5]}, workingdir="test_wf7b_{}".format(plugin))
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     na = NewNode(name="NA", interface=interf_addtwo, base_dir="na")
-
+    # using kwrg argument in the add method (instead of connect or connect_workflow
     wf.add(na, a="wf_a")
     wf.map(mapper="a")
     wf.run(plugin=plugin)
@@ -705,6 +728,7 @@ def test_workflow_9(plugin):
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     wf.add(name="NA", runnable=interf_addtwo, base_dir="na").map(mapper="a", inputs={"a": [3, 5]})
     interf_addvar = Function_Interface(fun_addvar, ["out"])
+    # _NA means that I'm using mapper from the NA node, it's the same as ("NA.a", "b")
     wf.add(name="NB", runnable=interf_addvar, base_dir="nb", a="NA.out").map(mapper=("_NA", "b"), inputs={"b": [2, 1]})
     wf.run(plugin=plugin)
 
@@ -733,6 +757,7 @@ def test_workflow_10(plugin):
     interf_addvar1 = Function_Interface(fun_addvar, ["out"])
     wf.add(name="NA", runnable=interf_addvar1, base_dir="na").map(mapper=("a", "b"), inputs={"a": [3, 5], "b": [0, 10]})
     interf_addvar2 = Function_Interface(fun_addvar, ["out"])
+    # _NA means that I'm using mapper from the NA node, it's the same as (("NA.a", NA.b), "b")
     wf.add(name="NB", runnable=interf_addvar2, base_dir="nb", a="NA.out").map(mapper=("_NA", "b"), inputs={"b": [2, 1]})
     wf.run(plugin=plugin)
 
@@ -761,6 +786,7 @@ def test_workflow_10a(plugin):
     interf_addvar1 = Function_Interface(fun_addvar, ["out"])
     wf.add(name="NA", runnable=interf_addvar1, base_dir="na").map(mapper=["a", "b"], inputs={"a": [3, 5], "b": [0, 10]})
     interf_addvar2 = Function_Interface(fun_addvar, ["out"])
+    # _NA means that I'm using mapper from the NA node, it's the same as (["NA.a", NA.b], "b")
     wf.add(name="NB", runnable=interf_addvar2, base_dir="nb", a="NA.out").map(mapper=("_NA", "b"), inputs={"b": [[2, 1], [0, 0]]})
     wf.run(plugin=plugin)
 
@@ -793,6 +819,7 @@ def test_workflow_11(plugin):
     interf_addtwo = Function_Interface(fun_addtwo, ["out"])
     wf.add(name="NB", runnable=interf_addtwo, base_dir="nb").map(mapper="a", inputs={"a": [2, 1]})
     interf_addvar2 = Function_Interface(fun_addvar, ["out"])
+    # _NA, _NB means that I'm using mappers from the NA/NB nodes, it's the same as [("NA.a", NA.b), "NB.a"]
     wf.add(name="NC", runnable=interf_addvar2, base_dir="nc", a="NA.out", b="NB.out").map(mapper=["_NA", "_NB"])
     wf.run(plugin=plugin)
 
@@ -816,6 +843,7 @@ def test_workflow_11(plugin):
 
 
 # tests for a workflow that have its own input and mapper
+#WIP
 
 #@pytest.mark.parametrize("plugin", Plugins)
 @python35_only