def respond_to_negotiation_request(self, initiator: str, partners: List[str], issues: List[Issue]
, annotation: Dict[str, Any], mechanism: MechanismProxy, role: Optional[str]
, req_id: str):
"""Called whenever a negotiation request is received"""
negotiator = AspirationNegotiator()
negotiator.utility_function = LinearUtilityAggregationFunction(issue_utilities=[lambda x: 1.0 - x / 10.0])
return negotiator
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_single_agreement_gets_one_agreement(n_negs, strict):
from negmas.mechanisms import Mechanism
from negmas.sao import SAOSingleAgreementRandomController, AspirationNegotiator
c = SAOSingleAgreementRandomController(strict=strict)
negs = [
SAOMechanism(issues=[Issue((0.0, 1.0), "price")],
n_steps=50,
outcome_type=tuple) for _ in range(n_negs)
]
for i, neg in enumerate(negs):
neg.add(
AspirationNegotiator(aspiration_type="linear",
name=f"opponent-{i}"),
ufun=LinearUtilityFunction(weights=[1.0]),
)
neg.add(c.create_negotiator(name=f"against-{i}"))
Mechanism.runall(negs, True)
agreements = [neg.state.agreement for neg in negs]
if strict:
# assert that the controller never had multiple agreements
assert sum(_ is not None for _ in agreements) == 1
else:
# assert that the controller never accepted twice. It may still have multiple agreements though
assert (len([
neg.state.agreement
for neg in negs if neg.state.agreement is not None
and neg.state.current_proposer.startswith("opponent")
]) < 2)
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_pickling_mechanism(tmp_path):
import 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_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_asp_negotaitor():
a1 = AspirationNegotiator(assume_normalized=True, name="a1")
a2 = AspirationNegotiator(assume_normalized=False, name="a2")
outcomes = [(_, ) for _ in range(10)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes, n_steps=100)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = neg.negotiator_offers(a1.id)
a2offers = neg.negotiator_offers(a2.id)
assert a1offers[0] == (9, )
assert a2offers[0] == (0, )
for i, offer in enumerate(_[0] for _ in a1offers):
assert i == 0 or offer <= a1offers[i - 1][0]
for i, offer in enumerate(_[0] for _ in a2offers):
assert i == 0 or offer >= a2offers[i - 1][0]
assert neg.state.agreement is not None
assert neg.state.agreement in ((4, ), (5, ))
def negotiator(self,
is_seller: bool,
issues=None) -> Optional[SAONegotiator]:
"""Creates a negotiator"""
if issues is None or not Issue.enumerate(issues, astype=tuple):
return None
return AspirationNegotiator(
ufun=self.create_ufun(is_seller=is_seller, issues=issues),
assume_normalized=True,
)
def _respond_to_negotiation_request(
self,
initiator: str,
partners: List[str],
issues: List[Issue],
annotation: Dict[str, Any],
mechanism: AgentMechanismInterface,
role: Optional[str],
req_id: Optional[str],
) -> Optional[Negotiator]:
negotiator = AspirationNegotiator(ufun=MappingUtilityFunction(
mapping=lambda x: 1.0 - x["i1"] / 10.0))
return negotiator
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_tough_asp_negotiator():
a1 = ToughNegotiator()
a2 = AspirationNegotiator(aspiration_type="conceder")
outcomes = [(_, ) for _ in range(10)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes, n_steps=100, outcome_type=tuple)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = neg.negotiator_offers(a1.id)
a2offers = neg.negotiator_offers(a2.id)
assert a1._offerable_outcomes is None
if len(a1offers) > 0:
assert len(set(a1offers)) == 1 and a1offers[-1] == (9, )
assert len(set(a2offers)) >= 0
def test_best_only_asp_negotiator():
a1 = OnlyBestNegotiator(dynamic_ufun=False, min_utility=0.9, top_fraction=0.1)
a2 = AspirationNegotiator(dynamic_ufun=False, aspiration_type='conceder')
outcomes = [(_,) for _ in range(20)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes, n_steps=200)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = [s.current_offer for s in neg.history if s.current_offerer == a1.id]
a2offers = [s.current_offer for s in neg.history if s.current_offerer == a2.id]
assert a1.offerable_outcomes is None
if len(a1offers) > 0:
assert len(set(a1offers)) <= 2 and min([u1[_[0]] for _ in a1offers if _ is not None]) >= 0.9
assert len(set(a2offers)) >= 1
def test_tough_asp_negotiator():
a1 = ToughNegotiator(dynamic_ufun=False)
a2 = AspirationNegotiator(dynamic_ufun=False, aspiration_type='conceder')
outcomes = [(_,) for _ in range(10)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes, n_steps=20)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = [s.current_offer for s in neg.history if s.current_offerer == a1.id]
a2offers = [s.current_offer for s in neg.history if s.current_offerer == a2.id]
assert a1.offerable_outcomes is None
if len(a1offers) > 0:
assert len(set(a1offers)) == 1 and a1offers[-1] == (9,)
assert len(set(a2offers)) >= 0
def test_best_only_asp_negotiator():
a1 = OnlyBestNegotiator(min_utility=0.9, top_fraction=0.1)
a2 = AspirationNegotiator(aspiration_type="conceder")
outcomes = [(_, ) for _ in range(20)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes, n_steps=200)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = neg.negotiator_offers(a1.id)
a2offers = neg.negotiator_offers(a2.id)
assert a1._offerable_outcomes is None
if len(a1offers) > 0:
assert (len(set(a1offers)) <= 2
and min([u1[_[0]] for _ in a1offers if _ is not None]) >= 0.9)
assert len(set(a2offers)) >= 1
def test_controller():
n_sessions = 5
c = SAOController(default_negotiator_type='negmas.sao.AspirationNegotiator'
, default_negotiator_params={'aspiration_type': 'conceder'})
sessions = [SAOMechanism(outcomes=10, n_steps=10) for _ in range(n_sessions)]
for session in sessions:
session.add(AspirationNegotiator(aspiration_type='conceder')
, ufun=RandomUtilityFunction(outcomes=session.outcomes))
session.add(c.create_negotiator(), ufun=RandomUtilityFunction(outcomes=session.outcomes))
completed: List[int] = []
while len(completed) < n_sessions:
for i, session in enumerate(sessions):
if i in completed:
continue
state = session.step()
if state.broken or state.timedout or state.agreement is not None:
completed.append(i)
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_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_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_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_tit_for_tat_against_asp_negotiators():
a1 = NaiveTitForTatNegotiator(name="a1")
a2 = AspirationNegotiator(name="a2")
outcomes = [(_, ) for _ in range(10)]
u1 = np.linspace(0.0, 1.0, len(outcomes))
u2 = 1.0 - u1
neg = SAOMechanism(outcomes=outcomes,
n_steps=10,
avoid_ultimatum=False,
time_limit=None)
neg.add(a1, ufun=u1)
neg.add(a2, ufun=u2)
neg.run()
a1offers = neg.negotiator_offers(a1.id)
a2offers = neg.negotiator_offers(a2.id)
assert a1offers[0] == (9, )
# assert a2offers[0] == (0,)
for i, offer in enumerate(_[0] for _ in a1offers):
assert i == 0 or offer <= a1offers[i - 1][0]
for i, offer in enumerate(_[0] for _ in a2offers):
assert i == 0 or offer >= a2offers[i - 1][0]
assert neg.state.agreement is not None
assert neg.state.agreement in ((1, ), (2, ), (3, ), (4, ), (5, ), (6, ))
def test_aspiration_continuous_issues(n_negotiators, n_issues, presort,
randomize_offers):
for k in range(5):
mechanism = SAOMechanism(
issues=[
Issue(values=(0.0, 1.0), name=f"i{i}") for i in range(n_issues)
],
n_steps=10,
)
ufuns = [
LinearUtilityFunction(
weights=[3.0 * random.random(), 2.0 * random.random()],
reserved_value=0.0,
) for _ in range(n_negotiators)
]
best_outcome = tuple([1.0] * n_issues)
worst_outcome = tuple([0.0] * n_issues)
i = 0
assert mechanism.add(
AspirationNegotiator(
name=f"agent{i}",
presort=presort,
randomize_offer=randomize_offers,
ufun=ufuns[i],
ufun_max=ufuns[i](best_outcome),
ufun_min=ufuns[i](worst_outcome),
)), "Cannot add negotiator"
for i in range(1, n_negotiators):
assert mechanism.add(
AspirationNegotiator(
name=f"agent{i}",
presort=presort,
randomize_offer=randomize_offers,
ufun_max=ufuns[i](best_outcome),
ufun_min=ufuns[i](worst_outcome),
),
ufun=ufuns[i],
), "Cannot add negotiator"
assert mechanism.state.step == 0
agents = dict(
zip([_.id for _ in mechanism.negotiators], mechanism.negotiators))
offers = defaultdict(list)
while not mechanism.state.ended:
mechanism.step()
for neg_id, offer in mechanism.state.new_offers:
assert neg_id in agents.keys()
neg = agents[neg_id]
prev = offers[neg_id]
last_offer = prev[-1] if len(prev) > 0 else float("inf")
if randomize_offers:
assert neg.utility_function(offer) <= neg.utility_function(
best_outcome)
else:
assert neg.utility_function(offer) <= last_offer
if not presort:
assert (
-neg.tolerance <=
(neg.utility_function(offer) - neg.aspiration(
(mechanism.state.step) / mechanism.n_steps) *
neg.utility_function(best_outcome)) <
pow(neg.tolerance, 0.5 / neg.n_trials) +
neg.tolerance)
# else:
# assert -neg.tolerance <= (
# neg.utility_function(offer)
# - neg.aspiration(
# (mechanism.state.step - 1) / mechanism.n_steps
# )
# * neg.utility_function(best_outcome)
# )
offers[neg_id].append(neg.utility_function(offer))
def test_can_run_from_checkpoint(tmp_path, single_checkpoint, checkpoint_every,
exist_ok):
import shutil
new_folder: Path = tmp_path / unique_name("empty", sep="")
second_folder: Path = tmp_path / unique_name("second", sep="")
new_folder.mkdir(parents=True, exist_ok=True)
shutil.rmtree(new_folder)
new_folder.mkdir(parents=True, exist_ok=True)
filename = "mechanism"
second_folder.mkdir(parents=True, exist_ok=True)
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])
mechanism.run()
files = list(new_folder.glob("*"))
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
runner = CheckpointRunner(folder=new_folder)
assert len(runner.steps) * 2 == len(files)
assert runner.current_step == -1
assert runner.loaded_object is None
runner.step()
assert runner.current_step == (0 if not single_checkpoint else
runner.steps[-1])
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.reset()
assert len(runner.steps) * 2 == len(files)
assert runner.current_step == -1
assert runner.loaded_object is None
runner.goto(runner.last_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.next_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.previous_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.first_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.reset()
runner.run()
def test_can_run_from_checkpoint(tmp_path, checkpoint_every, exist_ok, copy,
fork_after_reset):
import shutil
new_folder: Path = tmp_path / unique_name("empty", sep="")
second_folder: Path = tmp_path / unique_name("second", sep="")
new_folder.mkdir(parents=True, exist_ok=True)
shutil.rmtree(new_folder)
new_folder.mkdir(parents=True, exist_ok=True)
second_folder.mkdir(parents=True, exist_ok=True)
shutil.rmtree(second_folder)
second_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=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],
aspiration_type="conceder",
)
mechanism.run()
files = list(new_folder.glob("*"))
if 0 < checkpoint_every <= n_steps:
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
runner = CheckpointRunner(folder=new_folder)
assert len(runner.steps) * 2 == len(files)
assert runner.current_step == -1
assert runner.loaded_object is None
runner.step()
assert runner.current_step == 0
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.reset()
assert len(runner.steps) * 2 == len(files)
assert runner.current_step == -1
assert runner.loaded_object is None
runner.goto(runner.last_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.next_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.previous_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.first_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.reset()
if fork_after_reset:
m = runner.fork(copy_past_checkpoints=copy, folder=second_folder)
assert m is None
return
runner.step()
m = runner.fork(copy_past_checkpoints=copy, folder=second_folder)
if copy:
step = runner.current_step
assert len(list(second_folder.glob("*"))) >= 2
assert len(list(second_folder.glob(f"*{step}.mechanism"))) > 0
else:
assert len(list(second_folder.glob("*"))) == 0
assert isinstance(m, SAOMechanism)
step = m.current_step
m.step()
assert m.current_step == step + 1
state = m.run()
assert state.agreement is not None
runner.reset()
assert len(runner.steps) * 2 == len(files)
assert runner.current_step == -1
assert runner.loaded_object is None
runner.goto(runner.last_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.next_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.previous_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.goto(runner.first_step, exact=True)
assert isinstance(runner.loaded_object, SAOMechanism)
assert runner.loaded_object.state.step == runner.current_step
runner.reset()
runner.run()