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
