def test_default(self, op, old): w = Workflow(operations=[op]) result = w.execute_synchronous(executor=executor) corrected_images = result[0]['corrected_images'] gains = get_default(op, 'gains') assert np.array_equal(corrected_images, op.filled_values['images'] * gains[0]) if TEST_CSX_TOOLS: w.clear_operations() w.add_operation(old) result = w.execute_synchronous(executor=executor) assert np.array_equal(result[0]['corrected_images'], corrected_images)
def test_workflow(): from xicam.core.execution.workflow import Workflow from xicam.core.execution.daskexecutor import DaskExecutor from xicam.plugins.operationplugin import output_names executor = DaskExecutor() @operation @output_names("square") def square(a=3) -> int: return a**2 @operation @output_names("sum") def my_sum(a, b=3) -> int: return a + b wf = Workflow() square = square() my_sum = my_sum() wf.add_operation(square) wf.add_operation(my_sum) wf.add_link(square, my_sum, "square", "a") assert wf.execute_synchronous(executor=executor) == [{"sum": 12}]
def test_end_node(self, double_and_triple_op, sum_op, square_op): workflow = Workflow() workflow.add_operations(double_and_triple_op, sum_op, square_op) workflow.add_link(sum_op, square_op, "sum", "n") workflow.add_link(square_op, double_and_triple_op, "square", "n") result = workflow.execute_synchronous(n1=1, n2=2) assert result == ({"double": 18, "triple": 27}, )
def test_execute_synchronous(self, sum_op, square_op, negative_op): workflow = Workflow() workflow.add_operations(sum_op, square_op, negative_op) workflow.add_link(sum_op, square_op, "sum", "n") workflow.add_link(square_op, negative_op, "square", "num") results = workflow.execute_synchronous(n1=2, n2=5) assert results == ({"negative": -49}, )
def test_operation_links_multiple(self, sum_op, square_op, negative_op): # # (y) --> (n1) # my_func sum (n) --> (num) square # (x) --> (n2) # def my_func(x: int, y: int) -> (int, int): return y, x my_op = operation(my_func, output_names=("y", "x"))() workflow = Workflow() # workflow.add_operations(sum_op, square_op, negative_op, my_op) workflow.add_operations(my_op, sum_op, square_op, negative_op) link1 = (my_op, sum_op, "y", "n1") link2 = (my_op, sum_op, "x", "n2") link3 = (sum_op, square_op, "sum", "n") link4 = (square_op, negative_op, "square", "num") workflow.add_link(my_op, sum_op, "y", "n1") workflow.add_link(my_op, sum_op, "x", "n2") workflow.add_link(sum_op, square_op, "sum", "n") workflow.add_link(square_op, negative_op, "square", "num") # assert workflow.operation_links(my_op) == [link1, link2] # assert workflow.operation_links(sum_op) == [link3] # assert workflow.operation_links(square_op) == [link4] # assert workflow.operation_links(negative_op) == [] workflow._pretty_print() dask_graph, end_ids = workflow.as_dask_graph() # test execution results = workflow.execute_synchronous(x=3, y=5)
def test_execute_synchronous_no_links_not_enough_kwargs( self, sum_op, square_op, negative_op): # TODO -- expect exception workflow = Workflow() workflow.add_operations(sum_op, square_op, negative_op) results = workflow.execute_synchronous(n1=2, n2=5) assert results == ({"negative": -49}, )
def test_start_node(self, double_and_triple_op, sum_op, square_op): workflow = Workflow() workflow.add_operations(double_and_triple_op, sum_op, square_op) workflow.add_link(double_and_triple_op, sum_op, "double", "n1") workflow.add_link(double_and_triple_op, sum_op, "triple", "n2") workflow.add_link(sum_op, square_op, "sum", "n") result = workflow.execute_synchronous(n=1) assert result == ({"square": 25}, )
def test_mutliple_end_nodes(double_and_triple_op, sum_op, square_op): workflow = Workflow() workflow.add_operations(double_and_triple_op, sum_op, square_op) workflow.add_link(sum_op, double_and_triple_op, "sum", "n") workflow.add_link(sum_op, square_op, "sum", "n") result = workflow.execute_synchronous(n1=2, n2=3) assert len(result) == 2 assert {"double": 10, "triple": 15} in result assert {"square": 25} in result
def test_no_output_names(self): @operation def my_func(a1, a2): return a1, a2 op = my_func() w = Workflow() w.add_operations(op) result = w.execute_synchronous(a1=1, a2=2) assert result == ({"my_func": 1}, )
def test_one_output_name(self): @operation @output_names("return_val") def my_func(a1, a2): return a1, a2 op = my_func() workflow = Workflow() workflow.add_operations(op) result = workflow.execute_synchronous(a1=1, a2=2) assert result == ({"return_val": 1}, )
def test_execute_synchronous_no_links(self, sum_op, square_op, negative_op): workflow = Workflow() workflow.add_operations(sum_op, square_op, negative_op) # n1, n2 -- inputs to sum_op; # n -- input to square_op # num -- input to negative_op results = workflow.execute_synchronous(n1=2, n2=5, n=10, num=50) assert len(results) == 3 assert {"sum": 7} in results assert {"square": 100} in results assert {"negative": -50} in results
def test_all_output_names(self): @operation @output_names('x', 'y') def my_func(a1, a2): return a1, a2 op = my_func() workflow = Workflow() workflow.add_operations(op) result = workflow.execute_synchronous(a1=1, a2=2) print(result) assert result == ({'x': 1, 'y': 2}, )
def test_two_copy_ops_to_one_op(self, double_and_triple_op, sum_op, square_op): # 1**2 + 2**2 => 5 workflow = Workflow() square_op.filled_values.update(n=1) square_op_2 = square_op.__class__() square_op_2.filled_values.update(n=2) square_op_2.output_names = ["square"] workflow.add_operations(sum_op, square_op, square_op_2) workflow.add_link(square_op, sum_op, "square", "n1") workflow.add_link(square_op_2, sum_op, "square", "n2") workflow._pretty_print() result = workflow.execute_synchronous() assert result == ({"sum": 5},)
def test_multiple_instances(square_op, sum_op): from xicam.core.execution.workflow import Workflow from xicam.core.execution.daskexecutor import DaskExecutor executor = DaskExecutor() wf = Workflow() square = square_op() square2 = square_op() square2.filled_values["a"] = 2 my_sum = sum_op() wf.add_operation(square) wf.add_operation(square2) wf.add_operation(my_sum) wf.add_link(square, my_sum, "square", "a") # 3**3 wf.add_link(square2, my_sum, "square", "b") # 2**2 assert wf.execute_synchronous(executor=executor) == [{"sum": 13}]
def test_multiple_instances(square_op, sum_op): from xicam.core.execution.workflow import Workflow from xicam.core.execution.daskexecutor import DaskExecutor executor = DaskExecutor() wf = Workflow() square = square_op() square2 = square_op() square2.filled_values['a'] = 2 my_sum = sum_op() wf.add_operation(square) wf.add_operation(square2) wf.add_operation(my_sum) wf.add_link(square, my_sum, 'square', 'a') wf.add_link(square2, my_sum, 'square', 'b') assert wf.execute_synchronous(executor=executor) == [{'sum': 13}]
def test_execute_synchronous_no_links_not_enough_kwargs( self, sum_op, square_op, negative_op): workflow = Workflow() workflow.add_operations(sum_op, square_op, negative_op) with pytest.raises(TypeError): results = workflow.execute_synchronous(n1=2, n2=5)