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_propose(self): outcomes = [(_, ) for _ in range(10)] a1 = NaiveTitForTatNegotiator(name="a1", initial_concession="min") u1 = 22.0 - np.linspace(0.0, 22.0, len(outcomes)) neg = SAOMechanism(outcomes=outcomes, n_steps=10, avoid_ultimatum=False) neg.add(a1, ufun=u1) proposal = a1.propose_(neg.state) assert proposal == (0, ), "Proposes top first" proposal = a1.propose_(neg.state) assert proposal == ( 1, ), "Proposes second second if min concession is set" a1 = NaiveTitForTatNegotiator(name="a1") u1 = [50.0] * 3 + (22 - np.linspace(10.0, 22.0, len(outcomes) - 3)).tolist() neg = SAOMechanism(outcomes=outcomes, n_steps=10, avoid_ultimatum=False) neg.add(a1, ufun=u1) proposal = a1.propose_(neg.state) assert proposal == (0, ), "Proposes top first" proposal = a1.propose_(neg.state) assert proposal == ( 3, ), "Proposes first item with utility less than the top if concession is min"
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_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_opponent_negotiator(): from drl_negotiation.negotiator import MyOpponentNegotiator from negmas import Issue, SAOMechanism from drl_negotiation.utility_functions import MyUtilityFunction name = "test_opponent_negotiator" # seller weights = (0, 0.25, 1) issues = [ Issue(values=10, name="quantity"), Issue(values=100, name="delivery_time"), Issue(values=100, name="unit_price") ] mechanism = SAOMechanism(issues=issues, n_steps=100) ufun = MyUtilityFunction(weights=weights, ami=mechanism.ami) opponent_negotiator = MyOpponentNegotiator(name=name, ufun=ufun) mechanism.add(opponent_negotiator)
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_acceptable_outcomes(): p = SAOMechanism(outcomes=6, n_steps=10) p.add( LimitedOutcomesNegotiator(name="seller", acceptable_outcomes=[(2, ), (3, ), (5, )])) p.add( LimitedOutcomesNegotiator(name="buyer", acceptable_outcomes=[(1, ), (4, ), (3, )])) state = p.run() assert state.agreement == (3, )
def create_session( self) -> Union[Mechanism, anac2020_std, anac2020_collusion]: # self.check() if self.game_type == 'Negotiation' or self.game_type == 'DRLNegotiation': if self.session_data is None: self.set_session_data(data={}) if self._issues is not None: return SAOMechanism(issues=self.issues, n_steps=self.n_steps, **self.session_data) else: # Default issues return SAOMechanism(issues=[Issue((300, 550))], n_steps=self.n_steps, **self.session_data) if self.game_type == 'SCML' or self.game_type == 'DRLSCML': if self.session_data is None: self.session_data = {}
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_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_alternating_offers_mechanism_fails_on_no_offerer(): p = SAOMechanism( outcomes=10, n_steps=10, dynamic_entry=False, publish_n_acceptances=True, publish_proposer=True, ) to_be_offered = [(0, ), (1, ), (2, )] to_be_accepted = [(2, )] a1 = LimitedOutcomesAcceptor(acceptable_outcomes=to_be_offered) a2 = LimitedOutcomesAcceptor(acceptable_outcomes=to_be_accepted) p.add(a1, ufun=MappingUtilityFunction(lambda x: x[0] + 1.0)) p.add(a2, ufun=MappingUtilityFunction(lambda x: x[0] + 1.0)) try: p.run() except RuntimeError: pass a1offers = [ s.current_offer for s in p.history if s.current_proposer == a1.id ] a2offers = [ s.current_offer for s in p.history if s.current_proposer == a2.id ] assert len(p.history) > 0 assert len(a2offers) == 0, "acceptor did not offer" assert len(a1offers) == 0, "acceptor did not offer" assert p.agreement is None, "no agreement"
def test_can_run_all_negotiators(asdict): from negmas.helpers import instantiate issues = [Issue((0.0, 1.0), name="price"), Issue(10, name="quantity")] weights = dict(price=1.0, quantity=1.0) if asdict else (1.0, 1.0) for outcome_type in [tuple, dict]: outcomes = Issue.enumerate(issues, max_n_outcomes=100, astype=outcome_type) neg_types = [ ( "RandomNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "AspirationNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "LimitedOutcomesNegotiator", dict(acceptance_probabilities=0.5), ), ( "LimitedOutcomesAcceptor", dict(acceptance_probabilities=0.5), ), ( "ToughNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "OnlyBestNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "NaiveTitForTatNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "SimpleTitForTatNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ( "NiceNegotiator", dict(ufun=LinearUtilityFunction(weights=weights)), ), ] for i, (neg_type, params) in enumerate(neg_types): for n2, p2 in neg_types: print(f"{neg_type} <> {n2}") n1 = instantiate("negmas.sao." + neg_type, **params) n2 = instantiate("negmas.sao." + n2, **p2) m = SAOMechanism(n_steps=30, issues=issues, outcome_type=dict if asdict else tuple) m.add(n1) m.add(n2) m.run() assert not m.running
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_a_session(): start = time.monotonic() p = SAOMechanism(outcomes=50, n_steps=50) for _ in range(4): p.add(LimitedOutcomesNegotiator(outcomes=50, p_ending=0.01, name=f'agent {_}') , ufun=HyperRectangleUtilityFunction([None], [lambda x: x[0]])) p.run() # print(f'{len(p.negotiators)} negotiators') assert len(p.history) > 0
def test_alternating_offers_mechanism_with_one_agent_run(): n_outcomes, n_steps = 10, 10 accepted = [(2, ), (3, ), (4, ), (5, )] neg = SAOMechanism(outcomes=n_outcomes, n_steps=n_steps) opponent = LimitedOutcomesNegotiator( acceptable_outcomes=accepted, acceptance_probabilities=[1.0] * len(accepted), ) neg.add(opponent) neg.add(opponent) assert neg.pareto_frontier(sort_by_welfare=True)[0] == [(1.0, )] neg.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_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_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_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(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_tough_tit_for_tat_negotiator(): a1 = ToughNegotiator() a2 = NaiveTitForTatNegotiator() 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) # print(a1offers) # print(a2offers) 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_agent_checkpoint(tmp_path): a = DummyAgent(name="abcd") a.step_() file_name = a.checkpoint(tmp_path, info={"a": 3}) info = SAOMechanism.checkpoint_info(file_name) assert isinstance(info["time"], str) assert info["step"] == 1 assert info["type"].endswith("DummyAgent") assert info["id"] == a.id assert info["name"] == a.name == "abcd" assert info["a"] == 3 b = a.from_checkpoint(file_name) assert a.id == b.id b.step_()
def test_sync_controller_gets_all_offers(n_negs): from negmas.mechanisms import Mechanism from negmas.sao import SAORandomSyncController, RandomNegotiator class MyController(SAORandomSyncController): def counter_all(self, offers, states): assert len(offers) == len(self.active_negotiators) responses = super().counter_all(offers, states) assert len(responses) == len(offers) return responses c = MyController() negs = [ SAOMechanism(issues=[Issue((0.0, 1.0), "price")], n_steps=20) for _ in range(n_negs) ] for neg in negs: neg.add(RandomNegotiator()) neg.add(c.create_negotiator()) Mechanism.runall(negs, True)
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_agent_checkpoint_in_world(tmp_path): world = DummyWorld(n_steps=10) world.join(DummyAgent("A1")) world.join(DummyAgent("A2")) assert len(world.agents) == 2 for a in world.agents.values(): a.step_() file_name = a.checkpoint(tmp_path, info={"a": 3}) info = SAOMechanism.checkpoint_info(file_name) assert isinstance(info["time"], str) assert info["step"] == 1 assert info["type"].endswith("DummyAgent") assert info["id"] == a.id assert info["name"] == a.name assert info["a"] == 3 b = a.from_checkpoint(file_name) assert a.id == b.id b.step_()
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 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_tit_for_tat_negotiators(): a1 = NaiveTitForTatNegotiator(name="a1") a2 = NaiveTitForTatNegotiator(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, avoid_ultimatum=False) neg.add(a1, ufun=u1) neg.add(a2, ufun=u2) neg.run() a1offers = neg.negotiator_offers(a1.id) a2offers = neg.negotiator_offers(a2.id) # print(a1offers) # print(a2offers) 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 test_same_utility_leads_to_agreement(): n_outcomes, n_steps = 10, 10 accepted = [(2, ), (3, ), (4, ), (5, )] neg = SAOMechanism(outcomes=n_outcomes, n_steps=n_steps) opponent = LimitedOutcomesNegotiator( acceptable_outcomes=accepted, acceptance_probabilities=[1.0] * len(accepted), ) acceptor = LimitedOutcomesAcceptor( acceptable_outcomes=accepted, acceptance_probabilities=[1.0] * len(accepted), ) neg.add(opponent) neg.add(acceptor) assert neg.pareto_frontier(sort_by_welfare=True)[0] == [(1.0, 1.0)] state = neg.run() assert state.agreement is not None assert state.step < 4