def test_pickling_mechanism(tmp_path):
import dill as pickle
file = tmp_path / "mechanism.pck"
n_outcomes, n_negotiators = 5, 3
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=3,
offering_is_accepting=True,
avoid_ultimatum=False,
)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
assert mechanism.state.step == 0
with open(file, "wb") as f:
pickle.dump(mechanism, f)
with open(file, "rb") as f:
pickle.load(f)
assert mechanism.state.step == 0
mechanism.step()
with open(file, "wb") as f:
pickle.dump(mechanism, f)
with open(file, "rb") as f:
pickle.load(f)
assert mechanism.state.step == 1
def test_times_are_calculated(n_outcomes, n_negotiators, n_steps):
mechanism = SAOMechanism(outcomes=n_outcomes, n_steps=8)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
assert mechanism.state.step == 0
_strt = time.perf_counter()
for _ in range(n_steps):
# print(f"Stepping: {_}")
mechanism.step()
time.sleep(0.01)
duration = time.perf_counter() - _strt
# assert mechanism.current_step == n_steps
assert mechanism._current_offer is not None
assert len(mechanism.stats) == 3
stats = mechanism.stats
assert "round_times" in stats.keys()
assert 0 < sum(stats["round_times"]) < duration
assert "times" in stats.keys()
assert "exceptions" in stats.keys()
assert stats["times"] is not None
assert stats["exceptions"] is not None
assert len(stats["times"]) == n_negotiators
assert len(stats["exceptions"]) == 0
for i in range(n_negotiators):
assert 0 < stats["times"][mechanism.negotiators[i].id] < duration
assert len(stats["exceptions"][mechanism.negotiators[i].id]) == 0
assert 0 < sum(stats["times"].values()) < duration
def test_exceptions_are_saved():
n_outcomes, n_negotiators = 10, 2
mechanism = SAOMechanism(
outcomes=n_outcomes, n_steps=n_outcomes, ignore_negotiator_exceptions=True
)
ufuns = MappingUtilityFunction.generate_random(
n_negotiators, outcomes=mechanism.outcomes
)
mechanism.add(AspirationNegotiator(name=f"agent{0}"), ufun=ufuns[0])
mechanism.add(MyRaisingNegotiator(name=f"agent{1}"), ufun=ufuns[1])
assert mechanism.state.step == 0
mechanism.step()
mechanism.step()
mechanism.step()
assert mechanism.state.step == 1
assert mechanism._current_offer is not None
assert len(mechanism.stats) == 3
stats = mechanism.stats
assert "times" in stats.keys()
assert "exceptions" in stats.keys()
assert stats["exceptions"] is not None
assert len(stats["exceptions"]) == 1
# print(stats["exceptions"][mechanism.negotiators[1].id])
assert len(stats["exceptions"][mechanism.negotiators[1].id]) == 1
assert exception_str in stats["exceptions"][mechanism.negotiators[1].id][0]
assert len(stats["exceptions"][mechanism.negotiators[0].id]) == 0
def test_neg_sync_loop(keep_order):
# from pprint import pprint
n_outcomes, n_steps = 10, 10
waste_center = 0.1
c1 = MySyncController(sleep_seconds=waste_center, name="c1")
c2 = MySyncController(sleep_seconds=waste_center, name="c2")
mechanisms = []
for m in range(2):
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=n_steps,
ignore_negotiator_exceptions=False,
avoid_ultimatum=False,
name=f"{m}",
)
ufuns = MappingUtilityFunction.generate_random(2, outcomes=mechanism.outcomes)
mechanism.add(c1.create_negotiator(ufun=ufuns[0], id=f"0-{m}", name=f"0-{m}"))
mechanism.add(c2.create_negotiator(ufun=ufuns[1], id=f"1-{m}", name=f"1-{m}"))
mechanisms.append(mechanism)
SAOMechanism.runall(mechanisms, keep_order=keep_order)
for mechanism in mechanisms:
assert mechanism.state.started
assert mechanism.state.agreement is None
assert not mechanism.state.has_error
assert not mechanism.state.broken
assert mechanism.state.timedout
assert mechanism.state.step == n_steps
assert not mechanism.state.waiting
assert len(mechanism.history) == n_steps
def test_mechanism_can_run(n_negotiators):
n_outcomes = 5
mechanism = SAOMechanism(outcomes=n_outcomes, n_steps=3)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
assert mechanism.state.step == 0
mechanism.step()
mechanism.run()
def test_round_n_agents(n_negotiators):
n_outcomes = 5
mechanism = SAOMechanism(outcomes=n_outcomes, n_steps=3)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
assert mechanism.state.step == 0
mechanism.step()
assert mechanism.state.step == 1
assert mechanism._current_offer is not None
def test_checkpointing_mechanism(tmp_path):
file = tmp_path
n_outcomes, n_negotiators = 5, 3
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=3,
offering_is_accepting=True,
avoid_ultimatum=False,
)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
assert mechanism.state.step == 0
file_name = mechanism.checkpoint(file)
info = SAOMechanism.checkpoint_info(file_name)
assert isinstance(info["time"], str)
assert info["step"] == 0
assert info["type"].endswith("SAOMechanism")
assert info["id"] == mechanism.id
assert info["name"] == mechanism.name
mechanism, info = SAOMechanism.from_checkpoint(file_name, return_info=True)
assert isinstance(info["time"], str)
assert info["step"] == 0
assert info["type"].endswith("SAOMechanism")
assert info["id"] == mechanism.id
assert info["name"] == mechanism.name
assert mechanism.state.step == 0
mechanism.step()
file_name = mechanism.checkpoint(file)
info = SAOMechanism.checkpoint_info(file_name)
assert isinstance(info["time"], str)
assert info["step"] == 1
assert info["type"].endswith("SAOMechanism")
assert info["id"] == mechanism.id
assert info["name"] == mechanism.name
mechanism, info = SAOMechanism.from_checkpoint(file_name, return_info=True)
assert isinstance(info["time"], str)
assert info["step"] == 1
assert info["type"].endswith("SAOMechanism")
assert info["id"] == mechanism.id
assert info["name"] == mechanism.name
mechanism.run()
def test_neg_run_no_waiting():
n_outcomes, n_steps, waste = 10, 10, 0.5
mechanism = SAOMechanism(
outcomes=n_outcomes, n_steps=n_steps, ignore_negotiator_exceptions=True
)
ufuns = MappingUtilityFunction.generate_random(2, outcomes=mechanism.outcomes)
mechanism.add(TimeWaster(name=f"agent{0}", sleep_seconds=waste, ufun=ufuns[0]))
mechanism.add(TimeWaster(name=f"agent{1}", sleep_seconds=waste, ufun=ufuns[1]))
mechanism.run()
assert mechanism.state.agreement is None
assert mechanism.state.started
assert mechanism.state.timedout
assert mechanism.state.step == n_steps
assert not mechanism.state.waiting
assert len(mechanism.history) == n_steps
for _, v in mechanism.stats["times"].items():
assert v >= waste * n_steps
def test_mechanism_runall(n_negotiators, oia):
n_outcomes = 5
mechanisms = []
for _ in range(10):
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=random.randint(3, 20),
offering_is_accepting=oia,
avoid_ultimatum=False,
)
ufuns = MappingUtilityFunction.generate_random(1, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[0])
mechanisms.append(mechanism)
states = SAOMechanism.runall(mechanisms)
assert len(states) == 10
assert not any(_.running for _ in states)
def test_auto_checkpoint(tmp_path, single_checkpoint, checkpoint_every, exist_ok):
import shutil
new_folder: Path = tmp_path / unique_name("empty", sep="")
new_folder.mkdir(parents=True, exist_ok=True)
shutil.rmtree(new_folder)
new_folder.mkdir(parents=True, exist_ok=True)
filename = "mechanism"
n_outcomes, n_negotiators = 5, 3
n_steps = 50
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=n_steps,
offering_is_accepting=True,
avoid_ultimatum=False,
checkpoint_every=checkpoint_every,
checkpoint_folder=new_folder,
checkpoint_filename=filename,
extra_checkpoint_info=None,
exist_ok=exist_ok,
single_checkpoint=single_checkpoint,
)
ufuns = MappingUtilityFunction.generate_random(n_negotiators, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(
AspirationNegotiator(name=f"agent{i}"),
ufun=ufuns[i],
aspiration_type="conceder",
)
mechanism.run()
if 0 < checkpoint_every <= n_steps:
if single_checkpoint:
assert len(list(new_folder.glob("*"))) == 2
else:
assert len(list(new_folder.glob("*"))) >= 2 * (
max(1, mechanism.state.step // checkpoint_every)
)
elif checkpoint_every > n_steps:
assert len(list(new_folder.glob("*"))) == 2
else:
assert len(list(new_folder.glob("*"))) == 0
def test_mechanism_runs_with_offering_not_accepting(n_negotiators, oia):
n_outcomes = 5
mechanism = SAOMechanism(
outcomes=n_outcomes, n_steps=3, offering_is_accepting=oia, avoid_ultimatum=False
)
ufuns = MappingUtilityFunction.generate_random(1, outcomes=n_outcomes)
for i in range(n_negotiators):
mechanism.add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[0])
assert mechanism.state.step == 0
mechanism.step()
assert mechanism._current_proposer.name == "agent0"
assert mechanism._n_accepting == n_negotiators + int(oia) - 1
assert (mechanism.agreement is not None) is oia
if mechanism.agreement is not None:
return
mechanism.step()
assert mechanism._current_proposer.name == "agent0"
assert mechanism._n_accepting == n_negotiators
assert mechanism.agreement is not None
def test_neg_run_sync(n_negotiators):
n_outcomes, n_steps = 10, 10
waste_edge, waste_center = 0.2, 0.1
c = MySyncController(sleep_seconds=waste_center)
mechanisms, edge_names = [], []
for _ in range(n_negotiators):
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=n_steps,
ignore_negotiator_exceptions=True,
avoid_ultimatum=False,
)
ufuns = MappingUtilityFunction.generate_random(2, outcomes=mechanism.outcomes)
edge_names.append(f"f{0}")
mechanism.add(
TimeWaster(
name=f"agent{0}", id=f"a{0}", sleep_seconds=waste_edge, ufun=ufuns[0]
)
)
mechanism.add(c.create_negotiator(ufun=ufuns[1]))
mechanisms.append(mechanism)
SAOMechanism.runall(mechanisms)
for mechanism in mechanisms:
assert mechanism.state.started
assert mechanism.state.agreement is None
assert not mechanism.state.has_error
assert not mechanism.state.broken
assert mechanism.state.timedout, print(f"Did not timeout!!\n{mechanism.state}")
assert mechanism.state.step == n_steps
assert not mechanism.state.waiting
assert len(mechanism.history) == n_steps
delay_center = 0.0
for k, v in mechanism.stats["times"].items():
if k in edge_names:
assert v >= waste_edge * n_steps
else:
delay_center += v
assert delay_center > n_steps * waste_center
assert c.n_counter_all_calls == n_steps
def test_sync_controller(n_negotiations, n_negotiators, oia):
n_outcomes = 2
mechanisms = []
controller = MySAOSync()
for i in range(n_negotiators):
mechanisms.append(
SAOMechanism(
outcomes=n_outcomes,
n_steps=5,
offering_is_accepting=oia,
avoid_ultimatum=False,
)
)
ufuns = MappingUtilityFunction.generate_random(
n_negotiators, outcomes=n_outcomes
)
for i in range(n_negotiators):
mechanisms[-1].add(AspirationNegotiator(name=f"agent{i}"), ufun=ufuns[i])
mechanisms[-1].add(controller.create_negotiator())
states = SAOMechanism.runall(mechanisms)
assert all(_.agreement is not None for _ in states)
def test_single_mechanism_history_with_waiting(
avoid_ultimatum, n_steps, n_waits, n_waits2
):
n_outcomes, waste = 5, (0.0, 0.3)
mechanism = SAOMechanism(
outcomes=n_outcomes,
n_steps=n_steps,
ignore_negotiator_exceptions=False,
avoid_ultimatum=avoid_ultimatum,
)
ufuns = MappingUtilityFunction.generate_random(2, outcomes=mechanism.outcomes)
mechanism.add(
TimeWaster(
name=f"agent{0}", sleep_seconds=waste, ufun=ufuns[0], n_waits=n_waits
)
)
mechanism.add(
TimeWaster(
name=f"agent{1}", sleep_seconds=waste, ufun=ufuns[1], n_waits=n_waits2
)
)
mechanism.run()
first = mechanism._selected_first
n_negotiators = len(mechanism.negotiators)
assert (not avoid_ultimatum and first == 0) or (
avoid_ultimatum and 0 <= first < n_negotiators
)
assert mechanism.state.agreement is None
assert mechanism.state.started
assert mechanism.state.timedout or (
n_waits + n_waits2 > 0 and mechanism.state.broken
)
assert mechanism.state.step == n_steps or (
n_waits + n_waits2 > 0
and mechanism.state.broken
and mechanism.state.step <= n_steps
)
assert not mechanism.state.waiting
assert len(mechanism.history) == n_steps or (
n_waits + n_waits2 > 0
and mechanism.state.broken
and len(mechanism.history) <= n_steps
)
# check history details is correct
s = [defaultdict(int), defaultdict(int)]
r = [defaultdict(int), defaultdict(int)]
h = [defaultdict(int), defaultdict(int)]
first_offers = []
ignored_offers = []
for i, n in enumerate(mechanism.negotiators):
# print(f"Received, offered, respones for {i} ({n})")
# print(
# list(
# zip(
# zip(n.received_offers.keys(), n.received_offers.values()),
# zip(n.my_offers.keys(), n.my_offers.values()),
# )
# )
# )
# all agents asked to offer first if avoid_ultimatum
if avoid_ultimatum:
assert n.received_offers[0] is None
else:
first_offers.append(n.received_offers[0] is None)
# sent and received match
for j, w in n.my_offers.items():
# cannot send mutlipe offers in the same step
assert j not in s[i].keys()
# cannot send None
assert w is not None # or (j == 0 and not avoid_ultimatum)
if j == 0 and i != first and avoid_ultimatum:
# cannot have more than n_negotiators - 1 ignored offers
assert len(ignored_offers) < n_negotiators - 1
ignored_offers.append(w[0])
continue
s[i][j] = w[0]
for j, w in n.received_offers.items():
# cannot receive multiple ofers in the same step
assert j not in r[i].keys()
# canont be asked to start offering except in the first step
assert w is not None or j == 0
# this is the first agent to offer, ignore its first step
if (first == i and j == 0) or (avoid_ultimatum and j == 0):
# if this is the first agent, its first thing recieved must be None
assert w is None
continue
assert (
w is not None
), f"None outcome agent {i} @ {j} (avoid={avoid_ultimatum}) first is {first}"
r[i][j] = w[0]
# a single agent is asked to offer first if not avoid_ultimatum
if not avoid_ultimatum:
assert any(first_offers) and not all(first_offers)
# every agent is asked to offer and all except one are ignored if avoid_ultimatum
if avoid_ultimatum:
assert len(ignored_offers) == n_negotiators - 1
# reconstruct history
neg_map = dict(zip((_.id for _ in mechanism.negotiators), [0, 1]))
for state in mechanism.history:
for _, w in state.new_offers:
a = neg_map[_]
# cannot see the same step twice in the history of an agent
assert state.step not in h[a].keys()
h[a][state.step] = w
# no gaps in steps and all step sets start with 0 or 1
for i in range(len(mechanism.negotiators)):
for x in (r, s, h):
steps = list(x[i].keys())
if not steps:
continue
assert steps[0] in (0, 1)
for _ in range(len(steps) - 1):
assert steps[_] + 1 == steps[_ + 1]
# pprint([s, r, h])
# history matches what is stored inside agents
for i, n in enumerate(mechanism.negotiators):
for j, w in s[i].items():
assert j in r[1 - i] or (j == 0)
for j, w in r[i].items():
assert j in s[1 - i] or (j == 0 and not avoid_ultimatum)
# s and r will not have matched indices but should have matched values
s = [list(_.values()) for _ in s]
r = [list(_.values()) for _ in r]
h = [list(_[0] for _ in _.values()) for _ in h]
# history matches what is stored inside agents
for i, n in enumerate(mechanism.negotiators):
for j, w in enumerate(s[i]):
if j < len(r[1 - i]):
assert r[1 - i][j] == w
assert h[i][j] == w
for j, w in enumerate(r[i]):
assert s[1 - i][j] == w
