def test_quote(): literals = [[1, 2, 3], (add, 1, 2), [1, [2, 3]], (add, 1, (add, 2, 3)), { "x": "x" }] for le in literals: assert get({"x": quote(le)}, "x") == le
def test_local_parents_of_reduction(abcde): """ c1 | b1 c2 | /| a1 b2 c3 | /| a2 b3 | a3 Prefer to finish a1 stack before proceeding to b2 """ a, b, c, d, e = abcde a1, a2, a3 = [a + i for i in "123"] b1, b2, b3 = [b + i for i in "123"] c1, c2, c3 = [c + i for i in "123"] expected = [a3, a2, a1, b3, b2, b1, c3, c2, c1] log = [] def f(x): def _(*args): log.append(x) return _ dsk = { a3: (f(a3), ), a2: (f(a2), a3), a1: (f(a1), a2), b3: (f(b3), ), b2: (f(b2), b3, a2), b1: (f(b1), b2), c3: (f(c3), ), c2: (f(c2), c3, b2), c1: (f(c1), c2), } order(dsk) get(dsk, [a1, b1, c1]) # trigger computation assert log == expected
def endpoint_fn(body: request_model): session = body.session if body.session else str(uuid.uuid4()) _res = get( dsk_composition.dsk, dsk_composition.get_keys, cache=body.payload.dict(), sortkeys=dsk_composition.sortkeys, ) return { "result": dict(zip(dsk_composition.ep_dsk_output_keys, _res)), "session": session, }
def test_order_cycle(): with pytest.raises(RuntimeError, match="Cycle detected"): get({"a": (f, "a")}, "a") # we encounter this in `get` with pytest.raises(RuntimeError, match="Cycle detected"): order({"a": (f, "a")}) # trivial self-loop with pytest.raises(RuntimeError, match="Cycle detected"): order({("a", 0): (f, ("a", 0))}) # non-string with pytest.raises(RuntimeError, match="Cycle detected"): order({ "a": (f, "b"), "b": (f, "c"), "c": (f, "a") }) # non-trivial loop with pytest.raises(RuntimeError, match="Cycle detected"): order({"a": (f, "b"), "b": (f, "c"), "c": (f, "a", "d"), "d": 1}) with pytest.raises(RuntimeError, match="Cycle detected"): order({ "a": (f, "b"), "b": (f, "c"), "c": (f, "a", "d"), "d": (f, "b") })
def test_SubgraphCallable(): non_hashable = [1, 2, 3] dsk = { "a": (apply, add, ["in1", 2]), "b": ( apply, partial_by_order, ["in2"], { "function": func_with_kwargs, "other": [(1, 20)], "c": 4 }, ), "c": ( apply, partial_by_order, ["in2", "in1"], { "function": func_with_kwargs, "other": [(1, 20)] }, ), "d": (inc, "a"), "e": (add, "c", "d"), "f": ["a", 2, "b", (add, "b", (sum, non_hashable))], "h": (add, (sum, "f"), (sum, ["a", "b"])), } f = SubgraphCallable(dsk, "h", ["in1", "in2"], name="test") assert f.name == "test" assert repr(f) == "test" f2 = SubgraphCallable(dsk, "h", ["in1", "in2"], name="test") assert f == f2 f3 = SubgraphCallable(dsk, "g", ["in1", "in2"], name="test") assert f != f3 assert dict(f=None) assert hash(SubgraphCallable(None, None, [None])) assert hash(f3) != hash(f2) dsk2 = dsk.copy() dsk2.update({"in1": 1, "in2": 2}) assert f(1, 2) == get(cull(dsk2, ["h"])[0], ["h"])[0] assert f(1, 2) == f(1, 2) f2 = pickle.loads(pickle.dumps(f)) assert f2(1, 2) == f(1, 2)
def test_run_smaller_sections(abcde): r""" aa / | b d bb dd / \ /| | / a c e cc Prefer to run acb first because then we can get that out of the way """ a, b, c, d, e = abcde aa, bb, cc, dd = [x * 2 for x in [a, b, c, d]] expected = [a, c, b, e, d, cc, bb, aa, dd] log = [] def f(x): def _(*args): log.append(x) return _ dsk = { a: (f(a), ), c: (f(c), ), e: (f(e), ), cc: (f(cc), ), b: (f(b), a, c), d: (f(d), c, e), bb: (f(bb), cc), aa: (f(aa), d, bb), dd: (f(dd), cc), } get(dsk, [aa, b, dd]) assert log == expected
def __call__(self, *args): if not len(args) == len(self.inkeys): raise ValueError("Expected %d args, got %d" % (len(self.inkeys), len(args))) return get(self.dsk, self.outkey, dict(zip(self.inkeys, args)))