Add try-except-finally operation.

Author: tillahoffmann

.dockerignore

@@ -1,4 +1,4 @@
-**/__pycache__
-**/.git
-**/playground
-**/build
+.git/**/*
+.git/
+playground/**/*
+playground/

pythonflow/core.py

@@ -21,6 +21,8 @@
 import operator
 import uuid
 
+from .util import _noop_callback
+
 
 class Graph:
     """
@@ -301,12 +303,9 @@ def evaluate(self, context, callback=None):
         args = [partial(arg) for arg in self.args]
         kwargs = {key: partial(value) for key, value in self.kwargs.items()}
         # Evaluate the operation
-        if callback:
-            with callback(self, context):
-                context[self] = value = self._evaluate(*args, **kwargs)
-        else:
+        callback = callback or _noop_callback
+        with callback(self, context):
             context[self] = value = self._evaluate(*args, **kwargs)
-
         return value
 
     def _evaluate(self, *args, **kwargs):
@@ -333,6 +332,9 @@ def evaluate_operation(cls, operation, context, **kwargs):
             return slice(*[partial(getattr(operation, attr)) for attr in ['start', 'stop', 'step']])
         return operation
 
+    def __bool__(self):
+        return True
+
     def __hash__(self):
         return id(self)
 

pythonflow/operations.py

@@ -16,8 +16,10 @@
 
 import functools
 import logging
+import sys
 
 from .core import opmethod, Operation, func_op
+from .util import _noop_callback
 
 
 class placeholder(Operation):  # pylint: disable=C0103,R0903
@@ -52,13 +54,43 @@ def evaluate(self, context, callback=None):
         predicate, x, y = self.args  # pylint: disable=E0632,C0103
         # Evaluate the predicate and pick the right operation
         predicate = self.evaluate_operation(predicate, context)
-        if callback:
-            with callback(self, context):
-                context[self] = value = self.evaluate_operation(x if predicate else y, context)
-        else:
+        callback = callback or _noop_callback
+        with callback(self, context):
             context[self] = value = self.evaluate_operation(x if predicate else y, context)
         return value
 
+
+class try_(Operation):  # pylint: disable=C0103,W0223
+    """
+    Try to evaluate `operation`, fall back to operations
+    """
+    def __init__(self, operation, except_=None, finally_=None, **kwargs):
+        except_ = except_ or []
+        super(try_, self).__init__(operation, except_, finally_, **kwargs)
+
+    def evaluate(self, context, callback=None):
+        # Evaluate all dependencies first
+        self.evaluate_dependencies(context)
+
+        operation, except_, finally_ = self.args # pylint: disable=E0632,C0103
+        callback = callback or _noop_callback
+        with callback(self, context):
+            try:
+                context[self] = value = self.evaluate_operation(operation, context)
+                return value
+            except:
+                # Check the exceptions
+                _, ex, _ = sys.exc_info()
+                for type_, alternative in except_:
+                    if isinstance(ex, type_):
+                        context[self] = value = self.evaluate_operation(alternative, context)
+                        return value
+                raise
+            finally:
+                if finally_:
+                    self.evaluate_operation(finally_, context)
+
+
 @opmethod
 def identity(value):
     """

pythonflow/util.py

@@ -111,3 +111,8 @@ def __call__(self, operation, context):
 
     def __str__(self):
         return "\n".join(['%s: %s' % item for item in self.get_slow_operations(10).items()])
+
+
+@contextlib.contextmanager
+def _noop_callback(*_):
+    yield

tests/test_pythonflow.py

@@ -362,3 +362,30 @@ def test_slice():
         c = a[b:]
 
     assert len(graph(c)) == 99
+
+
+def test_bool():
+    with pf.Graph() as graph:
+        a = pf.placeholder()
+
+    assert a
+
+
+@pytest.mark.parametrize('context, expected', [
+    ({'a': 1, 'b': 0}, 'zero-division'),
+    ({'a': 1, 'b': 2}, 0.5),
+])
+def test_try(context, expected):
+    finally_reached = []
+
+    with pf.Graph() as graph:
+        a = pf.placeholder('a')
+        b = pf.placeholder('b')
+        c = pf.try_(
+            a / b,
+            [(ZeroDivisionError, 'zero-division')],
+            pf.func_op(lambda: finally_reached.append('done'))
+        )
+
+    assert graph(c, context) == expected
+    assert finally_reached