Merge branch 'master' into enh/DirectoryType

Author: djarecka

pydra/engine/helpers_state.py

@@ -10,6 +10,16 @@
 logger = logging.getLogger("pydra")
 
 
+class PydraStateError(Exception):
+    """Custom error for Pydra State"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{}".format(self.value)
+
+
 def splitter2rpn(splitter, other_states=None, state_fields=True):
     """
     Translate user-provided splitter into *reverse polish notation*.
@@ -49,7 +59,7 @@ def _ordering(
         if type(el[0]) is str and el[0].startswith("_"):
             node_nm = el[0][1:]
             if node_nm not in other_states and state_fields:
-                raise Exception(
+                raise PydraStateError(
                     "can't ask for splitter from {}, other nodes that are connected: {}".format(
                         node_nm, other_states.keys()
                     )
@@ -64,7 +74,7 @@ def _ordering(
         if type(el[1]) is str and el[1].startswith("_"):
             node_nm = el[1][1:]
             if node_nm not in other_states and state_fields:
-                raise Exception(
+                raise PydraStateError(
                     "can't ask for splitter from {}, other nodes that are connected: {}".format(
                         node_nm, other_states.keys()
                     )
@@ -87,7 +97,7 @@ def _ordering(
         if type(el[0]) is str and el[0].startswith("_"):
             node_nm = el[0][1:]
             if node_nm not in other_states and state_fields:
-                raise Exception(
+                raise PydraStateError(
                     "can't ask for splitter from {}, other nodes that are connected: {}".format(
                         node_nm, other_states.keys()
                     )
@@ -102,7 +112,7 @@ def _ordering(
         if type(el[1]) is str and el[1].startswith("_"):
             node_nm = el[1][1:]
             if node_nm not in other_states and state_fields:
-                raise Exception(
+                raise PydraStateError(
                     "can't ask for splitter from {}, other nodes that are connected: {}".format(
                         node_nm, other_states.keys()
                     )
@@ -125,7 +135,7 @@ def _ordering(
         if el.startswith("_"):
             node_nm = el[1:]
             if node_nm not in other_states and state_fields:
-                raise Exception(
+                raise PydraStateError(
                     "can't ask for splitter from {}, other nodes that are connected: {}".format(
                         node_nm, other_states.keys()
                     )
@@ -156,7 +166,7 @@ def _ordering(
                 state_fields=state_fields,
             )
     else:
-        raise Exception("splitter has to be a string, a tuple or a list")
+        raise PydraStateError("splitter has to be a string, a tuple or a list")
     if i > 0:
         output_splitter.append(current_sign)
 
@@ -702,7 +712,7 @@ def _single_op_splits_groups(op_single, combiner, inner_inputs, groups):
             return [], {}, [], combiner
         else:
             # TODO: probably not needed, should be already check by st.combiner_validation
-            raise Exception(
+            raise PydraStateError(
                 "all fields from the combiner have to be in splitter_rpn: {}, but combiner: {} is set".format(
                     [op_single], combiner
                 )
@@ -733,7 +743,7 @@ def combine_final_groups(combiner, groups, groups_stack, keys):
             elif gr in grs_removed:
                 pass
             else:
-                raise Exception(
+                raise PydraStateError(
                     "input {} not ready to combine, you have to combine {} "
                     "first".format(comb, groups_stack[-1])
                 )

pydra/engine/state.py

@@ -111,7 +111,9 @@ def splitter(self):
     @splitter.setter
     def splitter(self, splitter):
         if splitter and not isinstance(splitter, (str, tuple, list)):
-            raise Exception("splitter has to be a string, a tuple or a list")
+            raise hlpst.PydraStateError(
+                "splitter has to be a string, a tuple or a list"
+            )
         if splitter:
             self._splitter = hlpst.add_name_splitter(splitter, self.name)
         else:
@@ -209,7 +211,7 @@ def combiner(self):
     def combiner(self, combiner):
         if combiner:
             if not isinstance(combiner, (str, list)):
-                raise Exception("combiner has to be a string or a list")
+                raise hlpst.PydraStateError("combiner has to be a string or a list")
             self._combiner = hlpst.add_name_combiner(ensure_list(combiner), self.name)
         else:
             self._combiner = []
@@ -251,11 +253,13 @@ def other_states(self):
     def other_states(self, other_states):
         if other_states:
             if not isinstance(other_states, dict):
-                raise Exception("other states has to be a dictionary")
+                raise hlpst.PydraStateError("other states has to be a dictionary")
             else:
                 for key, val in other_states.items():
                     if not val:
-                        raise Exception(f"connection from node {key} is empty")
+                        raise hlpst.PydraStateError(
+                            f"connection from node {key} is empty"
+                        )
             self._other_states = other_states
         else:
             self._other_states = {}
@@ -360,7 +364,9 @@ def _left_right_check(self, splitter_part, check_nested=True):
         ):
             return "[Left, Right]"  # Left and Right parts separated in outer scalar
         else:
-            raise Exception("Left and Right splitters are mixed - splitter invalid")
+            raise hlpst.PydraStateError(
+                "Left and Right splitters are mixed - splitter invalid"
+            )
 
     def set_input_groups(self, state_fields=True):
         """Evaluate groups, especially the final groups that address the combiner."""
@@ -409,7 +415,7 @@ def _merge_previous_groups(self):
             ):
                 last_gr = last_gr - 1
             if left_nm[1:] not in self.other_states:
-                raise Exception(
+                raise hlpst.PydraStateError(
                     f"can't ask for splitter from {left_nm[1:]}, other nodes that are connected: {self.other_states}"
                 )
             st = self.other_states[left_nm[1:]][0]
@@ -434,7 +440,7 @@ def _merge_previous_groups(self):
                 )
                 self.keys_final += keys_f_st  # st.keys_final
                 if not hasattr(st, "group_for_inputs_final"):
-                    raise Exception("previous state has to run first")
+                    raise hlpst.PydraStateError("previous state has to run first")
                 group_for_inputs = group_for_inputs_f_st
                 groups_stack = groups_stack_f_st
                 self.left_combiner_all += combiner_all_st
@@ -487,7 +493,7 @@ def splitter_validation(self):
                 or spl.startswith("_")
                 or spl.split(".")[0] == self.name
             ):
-                raise Exception(
+                raise hlpst.PydraStateError(
                     "can't include {} in the splitter, consider using _{}".format(
                         spl, spl.split(".")[0]
                     )
@@ -497,9 +503,11 @@ def combiner_validation(self):
         """ validating if the combiner is correct (after all states are connected)"""
         if self.combiner:
             if not self.splitter:
-                raise Exception("splitter has to be set before setting combiner")
+                raise hlpst.PydraStateError(
+                    "splitter has to be set before setting combiner"
+                )
             if set(self._combiner) - set(self.splitter_rpn):
-                raise Exception("all combiners have to be in the splitter")
+                raise hlpst.PydraStateError("all combiners have to be in the splitter")
 
     def prepare_states(self, inputs, cont_dim=None):
         """

pydra/engine/tests/test_state.py

@@ -1,6 +1,7 @@
 import pytest
 
 from ..state import State
+from ..helpers_state import PydraStateError
 
 
 @pytest.mark.parametrize(
@@ -95,27 +96,27 @@ def test_state_1(
 
 
 def test_state_2_err():
-    with pytest.raises(Exception) as exinfo:
+    with pytest.raises(PydraStateError) as exinfo:
         st = State("NA", splitter={"a"})
     assert "splitter has to be a string, a tuple or a list" == str(exinfo.value)
 
 
 def test_state_3_err():
-    with pytest.raises(Exception) as exinfo:
+    with pytest.raises(PydraStateError) as exinfo:
         st = State("NA", splitter=["a", "b"], combiner=("a", "b"))
     assert "combiner has to be a string or a list" == str(exinfo.value)
 
 
 def test_state_4_err():
     st = State("NA", splitter="a", combiner=["a", "b"])
-    with pytest.raises(Exception) as exinfo:
+    with pytest.raises(PydraStateError) as exinfo:
         st.combiner_validation()
     assert "all combiners have to be in the splitter" in str(exinfo.value)
 
 
 def test_state_5_err():
     st = State("NA", combiner="a")
-    with pytest.raises(Exception) as exinfo:
+    with pytest.raises(PydraStateError) as exinfo:
         st.combiner_validation()
     assert "splitter has to be set before" in str(exinfo.value)
 
@@ -166,7 +167,7 @@ def test_state_connect_1b_exception():
     """can't provide explicitly NA.a (should be _NA)"""
     st1 = State(name="NA", splitter="a", other_states={})
     st2 = State(name="NB", splitter="NA.a")
-    with pytest.raises(Exception) as excinfo:
+    with pytest.raises(PydraStateError) as excinfo:
         st2.splitter_validation()
     assert "consider using _NA" in str(excinfo.value)
 
@@ -175,7 +176,7 @@ def test_state_connect_1b_exception():
 def test_state_connect_1c_exception(splitter2, other_states2):
     """can't ask for splitter from node that is not connected"""
     st1 = State(name="NA", splitter="a")
-    with pytest.raises(Exception) as excinfo:
+    with pytest.raises(PydraStateError) as excinfo:
         st2 = State(name="NB", splitter=splitter2, other_states=other_states2)
         st2.splitter_validation()
 
@@ -691,7 +692,7 @@ def test_state_connect_innerspl_1a():
 
 def test_state_connect_innerspl_1b():
     """incorrect splitter - Right & Left parts in scalar splitter"""
-    with pytest.raises(Exception):
+    with pytest.raises(PydraStateError):
         st1 = State(name="NA", splitter="a")
         st2 = State(name="NB", splitter=("_NA", "b"), other_states={"NA": (st1, "b")})
 
@@ -1718,7 +1719,7 @@ def test_connect_splitters(
     ],
 )
 def test_connect_splitters_exception_1(splitter, other_states):
-    with pytest.raises(Exception) as excinfo:
+    with pytest.raises(PydraStateError) as excinfo:
         st = State(name="CN", splitter=splitter, other_states=other_states)
     assert "Left and Right splitters are mixed" in str(excinfo.value)
 
@@ -1729,13 +1730,13 @@ def test_connect_splitters_exception_2():
         splitter="_NB",
         other_states={"NA": (State(name="NA", splitter="a"), "b")},
     )
-    with pytest.raises(Exception) as excinfo:
+    with pytest.raises(PydraStateError) as excinfo:
         st.set_input_groups()
     assert "can't ask for splitter from NB" in str(excinfo.value)
 
 
 def test_connect_splitters_exception_3():
-    with pytest.raises(Exception) as excinfo:
+    with pytest.raises(PydraStateError) as excinfo:
         st = State(
             name="CN",
             splitter="_NB",