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()