def test_update_state_with_processing():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'y')}
dependencies, dependents = get_deps(dsk)
waiting = {'z': {'y'}}
waiting_data = {'x': {'y'}, 'y': {'z'}, 'z': set()}
held_data = {'z'}
who_has = {'x': {'alice'}}
processing = {'y'}
released = set()
in_play = {'z', 'x', 'y'}
new_dsk = {'a': (inc, 'x'), 'b': (add, 'a', 'y'), 'c': (inc, 'z')}
new_keys = {'b', 'c'}
e_waiting = {'z': {'y'}, 'a': set(), 'b': {'a', 'y'}, 'c': {'z'}}
e_waiting_data = {
'x': {'y', 'a'},
'y': {'z', 'b'},
'z': {'c'},
'a': {'b'},
'b': set(),
'c': set()
}
e_held_data = {'b', 'c', 'z'}
update_state(dsk, dependencies, dependents, held_data, who_has, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'z', 'a', 'b', 'c'}
def test_update_state_supports_recomputing_released_results():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = dict()
waiting_data = {'z': set()}
held_data = {'z'}
who_has = {'z': {'alice'}}
processing = set()
released = {'x', 'y'}
in_play = {'z'}
new_dsk = {'x': 1, 'y': (inc, 'x')}
new_keys = {'y'}
e_dsk = dsk.copy()
e_waiting = {'x': set(), 'y': {'x'}}
e_waiting_data = {'x': {'y'}, 'y': set(), 'z': set()}
e_held_data = {'y', 'z'}
update_state(dsk, dependencies, dependents, held_data, who_has, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert dsk == e_dsk
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'z'}
def test_update_state_with_processing():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'y')}
dependencies, dependents = get_deps(dsk)
waiting = {'z': {'y'}}
waiting_data = {'x': {'y'}, 'y': {'z'}, 'z': set()}
who_wants = defaultdict(set, z={'client'})
wants_what = defaultdict(set, client={'z'})
who_has = {'x': {'alice'}}
processing = {'y'}
released = set()
in_play = {'z', 'x', 'y'}
new_dsk = {'a': (inc, 'x'), 'b': (add, 'a', 'y'), 'c': (inc, 'z')}
new_dependencies = {'a': {'x'}, 'b': {'a', 'y'}, 'c': {'z'}}
new_keys = {'b', 'c'}
e_waiting = {'z': {'y'}, 'a': set(), 'b': {'a', 'y'}, 'c': {'z'}}
e_waiting_data = {'x': {'y', 'a'}, 'y': {'z', 'b'}, 'z': {'c'},
'a': {'b'}, 'b': set(), 'c': set()}
e_who_wants = {'b': {'client'}, 'c': {'client'}, 'z': {'client'}}
e_wants_what = {'client': {'b', 'c', 'z'}}
update_state(dsk, dependencies, dependents, who_wants, wants_what,
who_has, in_play,
waiting, waiting_data, new_dsk, new_keys, new_dependencies,
'client')
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert who_wants == e_who_wants
assert wants_what == e_wants_what
assert in_play == {'x', 'y', 'z', 'a', 'b', 'c'}
def test_update_state_supports_recomputing_released_results():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = dict()
waiting_data = {'z': set()}
who_wants = defaultdict(set, z={'client'})
wants_what = defaultdict(set, client={'z'})
who_has = {'z': {'alice'}}
processing = set()
released = {'x', 'y'}
in_play = {'z'}
new_dsk = {'x': 1, 'y': (inc, 'x')}
new_dependencies = {'y': {'x'}}
new_keys = {'y'}
e_dsk = dsk.copy()
e_waiting = {'x': set(), 'y': {'x'}}
e_waiting_data = {'x': {'y'}, 'y': set(), 'z': set()}
e_who_wants = {'z': {'client'}, 'y': {'client'}}
e_wants_what = {'client': {'y', 'z'}}
update_state(dsk, dependencies, dependents, who_wants, wants_what, who_has,
in_play, waiting, waiting_data, new_dsk, new_keys,
new_dependencies, 'client')
assert dsk == e_dsk
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert who_wants == e_who_wants
assert wants_what == e_wants_what
assert in_play == {'x', 'y', 'z'}
def test_update_state_supports_recomputing_released_results():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = dict()
waiting_data = {'z': set()}
who_wants = defaultdict(set, z={'client'})
wants_what = defaultdict(set, client={'z'})
who_has = {'z': {'alice'}}
processing = set()
released = {'x', 'y'}
in_play = {'z'}
new_dsk = {'x': 1, 'y': (inc, 'x')}
new_dependencies = {'y': {'x'}}
new_keys = {'y'}
e_dsk = dsk.copy()
e_waiting = {'x': set(), 'y': {'x'}}
e_waiting_data = {'x': {'y'}, 'y': set(), 'z': set()}
e_who_wants = {'z': {'client'}, 'y': {'client'}}
e_wants_what = {'client': {'y', 'z'}}
update_state(dsk, dependencies, dependents, who_wants, wants_what,
who_has, in_play,
waiting, waiting_data, new_dsk, new_keys, new_dependencies,
'client')
assert dsk == e_dsk
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert who_wants == e_who_wants
assert wants_what == e_wants_what
assert in_play == {'x', 'y', 'z'}
def test_update_state_with_processing():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'y')}
dependencies, dependents = get_deps(dsk)
waiting = {'z': {'y'}}
waiting_data = {'x': {'y'}, 'y': {'z'}, 'z': set()}
held_data = {'z'}
who_has = {'x': {'alice'}}
processing = {'y'}
released = set()
in_play = {'z', 'x', 'y'}
new_dsk = {'a': (inc, 'x'), 'b': (add, 'a', 'y'), 'c': (inc, 'z')}
new_keys = {'b', 'c'}
e_waiting = {'z': {'y'}, 'a': set(), 'b': {'a', 'y'}, 'c': {'z'}}
e_waiting_data = {'x': {'y', 'a'}, 'y': {'z', 'b'}, 'z': {'c'},
'a': {'b'}, 'b': set(), 'c': set()}
e_held_data = {'b', 'c', 'z'}
update_state(dsk, dependencies, dependents, held_data,
who_has, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'z', 'a', 'b', 'c'}
def test_update_state_supports_recomputing_released_results():
dsk = {'x': 1, 'y': (inc, 'x'), 'z': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = dict()
waiting_data = {'z': set()}
held_data = {'z'}
who_has = {'z': {'alice'}}
processing = set()
released = {'x', 'y'}
in_play = {'z'}
new_dsk = {'x': 1, 'y': (inc, 'x')}
new_keys = {'y'}
e_dsk = dsk.copy()
e_waiting = {'x': set(), 'y': {'x'}}
e_waiting_data = {'x': {'y'}, 'y': set(), 'z': set()}
e_held_data = {'y', 'z'}
update_state(dsk, dependencies, dependents, held_data,
who_has, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert dsk == e_dsk
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'z'}
def test_update_state_respects_WrappedKeys():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = {'y': set()}
waiting_data = {'x': {'y'}, 'y': set()}
held_data = {'y'}
who_has = {'x': {'alice'}}
processing = set()
released = set()
in_play = {'x', 'y'}
e_dsk = {'x': 1, 'y': (inc, 'x'), 'a': 1, 'z': (add, 'y', 'a')}
e_dependencies = {'x': set(), 'a': set(), 'y': {'x'}, 'z': {'a', 'y'}}
e_dependents = {'z': set(), 'y': {'z'}, 'a': {'z'}, 'x': {'y'}}
e_waiting = {'y': set(), 'a': set(), 'z': {'a', 'y'}}
e_waiting_data = {'x': {'y'}, 'y': {'z'}, 'a': {'z'}, 'z': set()}
e_held_data = {'y', 'z'}
new_dsk = {'z': (add, WrappedKey('y'), 10)}
a = update_state(*map(deepcopy, [dsk, dependencies, dependents, held_data,
who_has, in_play,
waiting, waiting_data, new_dsk, {'z'}]))
new_dsk = {'z': (add, 'y', 10)}
b = update_state(*map(deepcopy, [dsk, dependencies, dependents, held_data,
who_has, in_play,
waiting, waiting_data, new_dsk, {'z'}]))
assert a == b
def test_update_state_respects_data_in_memory():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = dict()
waiting_data = {'y': set()}
held_data = {'y'}
in_memory = {'y'}
processing = set()
released = {'x'}
in_play = {'y'}
new_dsk = {'x': 1, 'y': (inc, 'x'), 'z': (add, 'y', 'x')}
new_keys = {'z'}
e_dsk = new_dsk.copy()
e_waiting = {'z': {'x'}, 'x': set()}
e_waiting_data = {'x': {'z'}, 'y': {'z'}, 'z': set()}
e_held_data = {'y', 'z'}
update_state(dsk, dependencies, dependents, held_data,
in_memory, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert dsk == e_dsk
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'z'}
def test_update_state_respects_WrappedKeys():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies, dependents = get_deps(dsk)
waiting = {'y': set()}
waiting_data = {'x': {'y'}, 'y': set()}
held_data = {'y'}
in_memory = {'x'}
processing = set()
released = set()
in_play = {'x', 'y'}
e_dsk = {'x': 1, 'y': (inc, 'x'), 'a': 1, 'z': (add, 'y', 'a')}
e_dependencies = {'x': set(), 'a': set(), 'y': {'x'}, 'z': {'a', 'y'}}
e_dependents = {'z': set(), 'y': {'z'}, 'a': {'z'}, 'x': {'y'}}
e_waiting = {'y': set(), 'a': set(), 'z': {'a', 'y'}}
e_waiting_data = {'x': {'y'}, 'y': {'z'}, 'a': {'z'}, 'z': set()}
e_held_data = {'y', 'z'}
new_dsk = {'z': (add, WrappedKey('y'), 10)}
a = update_state(*map(deepcopy, [dsk, dependencies, dependents, held_data,
in_memory, in_play,
waiting, waiting_data, new_dsk, {'z'}]))
new_dsk = {'z': (add, 'y', 10)}
b = update_state(*map(deepcopy, [dsk, dependencies, dependents, held_data,
in_memory, in_play,
waiting, waiting_data, new_dsk, {'z'}]))
assert a == b
def test_update_state():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies = {'x': set(), 'y': {'x'}}
dependents = {'x': {'y'}, 'y': set()}
waiting = {'y': set()}
waiting_data = {'x': {'y'}, 'y': set()}
who_wants = defaultdict(set, y={'client'})
wants_what = defaultdict(set, client={'y'})
who_has = {'x': {'alice'}}
processing = set()
released = set()
in_play = {'x', 'y'}
new_dsk = {'a': 1, 'z': (add, 'y', 'a')}
new_dependencies = {'z': {'y', 'a'}}
new_keys = {'z'}
e_dsk = {'x': 1, 'y': (inc, 'x'), 'a': 1, 'z': (add, 'y', 'a')}
e_dependencies = {'x': set(), 'a': set(), 'y': {'x'}, 'z': {'a', 'y'}}
e_dependents = {'z': set(), 'y': {'z'}, 'a': {'z'}, 'x': {'y'}}
e_waiting = {'y': set(), 'a': set(), 'z': {'a', 'y'}}
e_waiting_data = {'x': {'y'}, 'y': {'z'}, 'a': {'z'}, 'z': set()}
e_who_wants = {'z': {'client'}, 'y': {'client'}}
e_wants_what = {'client': {'y', 'z'}}
update_state(dsk, dependencies, dependents, who_wants, wants_what, who_has,
in_play, waiting, waiting_data, new_dsk, new_keys,
new_dependencies, 'client')
assert dsk == e_dsk
assert dependencies == e_dependencies
assert dependents == e_dependents
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert who_wants == e_who_wants
assert wants_what == e_wants_what
assert in_play == {'x', 'y', 'a', 'z'}
def test_update_state():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies = {'x': set(), 'y': {'x'}}
dependents = {'x': {'y'}, 'y': set()}
waiting = {'y': set()}
waiting_data = {'x': {'y'}, 'y': set()}
held_data = {'y'}
who_has = {'x': {'alice'}}
processing = set()
released = set()
in_play = {'x', 'y'}
new_dsk = {'a': 1, 'z': (add, 'y', 'a')}
new_keys = {'z'}
e_dsk = {'x': 1, 'y': (inc, 'x'), 'a': 1, 'z': (add, 'y', 'a')}
e_dependencies = {'x': set(), 'a': set(), 'y': {'x'}, 'z': {'a', 'y'}}
e_dependents = {'z': set(), 'y': {'z'}, 'a': {'z'}, 'x': {'y'}}
e_waiting = {'y': set(), 'a': set(), 'z': {'a', 'y'}}
e_waiting_data = {'x': {'y'}, 'y': {'z'}, 'a': {'z'}, 'z': set()}
e_held_data = {'y', 'z'}
update_state(dsk, dependencies, dependents, held_data,
who_has, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert dsk == e_dsk
assert dependencies == e_dependencies
assert dependents == e_dependents
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'a', 'z'}
def test_update_state():
dsk = {'x': 1, 'y': (inc, 'x')}
dependencies = {'x': set(), 'y': {'x'}}
dependents = {'x': {'y'}, 'y': set()}
waiting = {'y': set()}
waiting_data = {'x': {'y'}, 'y': set()}
held_data = {'y'}
in_memory = {'x'}
processing = set()
released = set()
in_play = {'x', 'y'}
new_dsk = {'a': 1, 'z': (add, 'y', 'a')}
new_keys = {'z'}
e_dsk = {'x': 1, 'y': (inc, 'x'), 'a': 1, 'z': (add, 'y', 'a')}
e_dependencies = {'x': set(), 'a': set(), 'y': {'x'}, 'z': {'a', 'y'}}
e_dependents = {'z': set(), 'y': {'z'}, 'a': {'z'}, 'x': {'y'}}
e_waiting = {'y': set(), 'a': set(), 'z': {'a', 'y'}}
e_waiting_data = {'x': {'y'}, 'y': {'z'}, 'a': {'z'}, 'z': set()}
e_held_data = {'y', 'z'}
update_state(dsk, dependencies, dependents, held_data,
in_memory, in_play,
waiting, waiting_data, new_dsk, new_keys)
assert dsk == e_dsk
assert dependencies == e_dependencies
assert dependents == e_dependents
assert waiting == e_waiting
assert waiting_data == e_waiting_data
assert held_data == e_held_data
assert in_play == {'x', 'y', 'a', 'z'}