def test_get_intermediate_results():
r1 = add(1, 1)
r2 = sub(3, r1)
def foo(a, b, c):
return mul(add(a, b), c)
r3 = [foo(i, r2, r1) for i in range(6)]
r4 = accumulate(noodles.gather_all(r3))
run_single(r4)
assert noodles.result(r1) == 2
assert noodles.result(r2) == 1
assert [noodles.result(r) for r in r3] == [2, 4, 6, 8, 10, 12]
assert noodles.result(r4) == 42
def test_iterate():
a = noodles.delay((1,2,3))
b, c, d = a
e = noodles.gather(d, c, b)
result = noodles.run_single(e)
assert result == (3, 2, 1)
def test_rastrigin_zero():
rastrigin = Rastrigin(10)
values = np.zeros(10)
answer = run_single(rastrigin.evaluate(values))
print("For values {:s} found answer: {:s}", values, answer)
assert answer == 0
def test_rastrigin_zero():
rastrigin = Rastrigin(10)
values = np.zeros(10)
answer = run_single(rastrigin.evaluate(values))
print("For values {:s} found answer: {:s}", values,answer)
assert answer == 0
def test_sort():
a = [random_number() for i in range(10)]
b = noodles.gather(*sorted(a))
result = noodles.run_single(b)
print(result)
assert result == sorted(result)
def test_iterate():
with raises(TypeError):
a = noodles.delay((1, 2, 3))
b, c, d = a
e = noodles.gather(d, c, b)
result = noodles.run_single(e)
assert result == (3, 2, 1)
def test_lift_01():
a = A()
a.x = add(1, 2)
a.y = sub(9, 11)
b = f(lift(a))
result = run_single(b)
assert result == 1
def test_runner_01():
A = value(1)
B = value(1)
C = add(A, B)
assert run_single(C) == 2
assert result(A) == 1
assert result(B) == 1
def test_select_max_list(mocker):
"""
Test select_max using mocked results
"""
results = generate_mocked_results(mocker, 'qmflows.packages.SCM.ADF_Result', expected=1e3)
wf = select_max(results, prop='prop')
xs = run_single(wf)
assert xs.prop == 1e3
def test_select_min(mocker):
"""
Test select_min using mocked results
"""
results = generate_mocked_results(mocker, 'qmflows.packages.SCM.DFTB_Result', expected=-1e3)
wf = select_min(results, prop='prop')
xs = run_single(wf)
assert xs.prop == -1e3
def test_nonstorable():
a = A()
b = M()
a.x = 1
b.x = f(3, 4)
zzc = g(a, b)
result = run_single(c)
assert result == 8
def test_runner_02():
A = add(1, 1)
B = sub(3, A)
multiples = [mul(add(i, B), A) for i in range(6)]
C = sum(gather(*multiples))
assert run_single(C) == 42
assert result(C) == 42
assert result(A) == 2
def test_tuple_unpack():
a = Scheduled()
b = Scheduled()
a.x, a.y = 2, 3
b.x, b.y = sub(a.x, a.y), sub(a.y, a.x)
result = run_single(b)
assert result.x == -1
assert result.y == 1
def test_tuple_unpack():
a = Scheduled()
b = Scheduled()
a.x, a.y = 2, 3
b.x, b.y = sub(a.x, a.y), sub(a.y, a.x)
result = run_single(b)
assert result.x == -1
assert result.y == 1
def test_class_property():
a = make_object(A, 10)
a.attr = 1.0
b = make_object(B)
b.first = a.attr
b.second = a.mul_attr(3)
result = run_single(b)
assert result.first == 0.25
assert result.second == 1.5
def test_nonstorable():
with raises(TypeError):
a = A()
b = M()
a.x = 1
b.x = f(3, 4)
c = g(a, b)
result = run_single(c)
assert result == 8
def test_select_max_list(mocker):
"""
Test select_max using mocked results
"""
results = generate_mocked_results(mocker,
'qmflows.packages.SCM.ADF_Result',
expected=1e3)
wf = select_max(results, prop='prop')
xs = run_single(wf)
assert xs.prop == 1e3
def test_arg_by_ref():
n = Normal()
s = Scheduled()
n.x = 4
s.x = n
n.x = 5
s.y = n
result = run_single(s)
assert result.x.x == 4
assert result.y.x == 5
def test_select_min(mocker):
"""
Test select_min using mocked results
"""
results = generate_mocked_results(mocker,
'qmflows.packages.SCM.DFTB_Result',
expected=-1e3)
wf = select_min(results, prop='prop')
xs = run_single(wf)
assert xs.prop == -1e3
def test_arg_by_ref():
n = Normal()
s = Scheduled()
n.x = 4
s.x = n
n.x = 5
s.y = n
result = run_single(s)
assert result.x.x == 4
assert result.y.x == 5
def test_find_first():
global counter
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_single(w)
assert result == 16
assert counter == 5
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_process(w, n_processes=1, registry=base)
assert result == 16
wfs = [display_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
with NCDisplay() as display:
result = run_logging(w, n_threads=2, display=display)
assert result == 16
def test_find_first():
global counter
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_single(w)
assert result == 16
assert counter == 5
wfs = [counted_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
result = run_process(w, n_processes=1, registry=base)
assert result == 16
wfs = [display_sqr(x) for x in range(10)]
w = find_first(is_sixteen, wfs)
with NCDisplay() as display:
result = run_logging(w, n_threads=2, display=display)
assert result == 16
def run(
wf: object,
runner: str = 'parallel',
n_processes: int = 1,
cache: str = 'cache.db',
) -> Any:
"""Run a workflow `wf` using `runner` and `n_processes` number of threads/process."""
runner = runner.lower()
if isinstance(wf, Results):
wf = gather_dict(**wf.state)
if runner == 'display':
with NCDisplay() as display:
return run_logging(wf, n_processes, display)
elif runner == 'serial':
return run_single(wf)
else:
return run_provenance(wf,
n_threads=n_processes,
db_file=cache,
registry=registry,
echo_log=False,
always_cache=False)
def test_private():
a = add(1, 1)
a._private = 3
assert a._private == 3
assert not hasattr(run_single(a), '_private')
def test_class_decorator2():
with raises(AttributeError):
a = make_object(A, 6).multiply(7)
b = a.divide(0)
result = run_single(b)
print(dir(result))
import numpy
import noodles
import time
from copy import copy
@noodles.schedule(call_by_ref=['gobble'])
def factorial_tr(x, acc=1, gobble=None):
time.sleep(0.1)
if x == 0:
return acc
else:
return factorial_tr(x - 1, acc * x, copy(gobble))
gobble_size = 10000000
gobble = numpy.zeros(gobble_size)
result = noodles.run_single(factorial_tr(10, gobble=gobble))
def test_class_decorator():
a = make_object(A, 5).multiply(10)
a.second = 7
result = run_single(a)
assert result.value == 50
assert result.second == 7
def test_truthfulness():
w = sub(4, add(3, 2))
a = cond(True, w, should_not_run())
b = cond(False, should_not_run(), w)
result = run_single(mul(a, b))
assert result == 1
from noodles import (schedule, maybe, run_single)
@schedule
@maybe
def inv(x):
return 1 / x
@schedule
@maybe
def add(**args):
return sum(args.values())
if __name__ == "__main__":
wf = add(a=inv(0), b=inv(0))
result = run_single(wf)
print(result)
@property
def attr(self):
return sqr(self.__attr)
def mul_attr(self, factor=1):
return mul(self.__attr, factor)
@attr.setter
def attr(self, x):
self.__attr = divide(x, 2)
@schedule
class B:
pass
a = A(5).multiply(10)
a.second = 7
a.attr = 1.0
b = B()
b.x = a.x
b.second = a.second
b.attr = a.attr
draw_workflow("oop-wf.svg", b._workflow)
result = run_single(b)
print(result.x, result.second, result.attr)
def test_class_methods_00():
a = A(7)
b = a(6)
result = run_single(b)
assert result == 42
def test_exception_00():
with raises(MyException):
wf = raises_my_exception()
run_single(wf)
def test_private():
a = add(1, 1)
a._private = 3
assert a._private == 3
assert not hasattr(run_single(a), '_private')
def test_exception_01():
with raises(TypeError):
wf = not_really_annotated()
run_single(wf)
def test_class_methods_00():
a = A(7)
b = a(6)
result = run_single(b)
assert result == 42
def test_exception_00():
wf = raises_my_exception()
run_single(wf)
from noodles import (schedule, run_single)
from noodles.tutorial import (add)
from noodles.draw_workflow import draw_workflow
@schedule
class A:
def __init__(self, value):
self.value = value
@property
def square(self):
return self.value**2
@square.setter
def square(self, sqr):
self.value = sqr**(1 / 2)
u = A(3)
v = A(4)
u.square = add(u.square, v.square)
draw_workflow("pythagoras.pdf", u.value._workflow)
print("⎷(3² + 4²) = ", run_single(u.value))
def test_exception_01():
wf = not_really_annotated()
run_single(wf)
def test_truthfulness():
w = sub(4, add(3, 2))
a = cond(True, w, should_not_run())
b = cond(False, should_not_run(), w)
result = run_single(mul(a, b))
assert result == 1
def test_unpack_00():
a, b, c = unpack(f(), 3)
d = run_single(add(a, add(b, c)))
assert d == 6
from noodles import (schedule, run_single)
@schedule
def double(x):
return x['value'] * 2
@schedule
def add(x, y):
return x + y
a = {'value': 4}
b = double(a)
a['value'] = 5
c = double(a)
d = add(b, c)
print(run_single(d))
from noodles import (schedule, run_single)
@schedule
def double(x):
return x['value'] * 2
@schedule
def add(x, y):
return x + y
a = {'value': 4}
b = double(a)
a['value'] = 5
c = double(a)
d = add(b, c)
print(run_single(d))
