MiCROOfferingPolicy

class negmas.sao.MiCROOfferingPolicy(next_indx: int = 0, sorter: PresortingInverseUtilityFunction | None = None, received: set[Outcome] = NOTHING, sent: set[Outcome] = NOTHING, *, negotiator: GBNegotiator | None = None)[source]

Bases: OfferingPolicy

Attributes Summary

`negotiator`
`next_indx`
`sorter`

Methods Summary

`__call__`(state[, dest])	Call self as a function.
`after_join`(nmi)	A call back called after joining a negotiation to confirm wwe joined.
`after_proposing`(state, offer[, dest])	Called after proposing
`after_responding`(state, offer, response[, ...])	Called before offering
`before_proposing`(state[, dest])	Called before proposing
`before_responding`(state, offer[, source])	Called before offering
`best_offer_so_far`()
`can_join`(nmi, state, *[, preferences, ufun, ...])	A call back called before joining a negotiation to confirm that we can join it.
`ensure_sorter`()
`next_offer`()
`on_leave`(state)	A call back called after leaving a negotiation.
`on_mechanism_error`(state)	A call back called whenever an error happens in the mechanism.
`on_negotiation_end`(state)	A call back called at each negotiation end
`on_negotiation_start`(state)	A call back called at each negotiation start
`on_partner_ended`(partner)	Called when a partner ends the negotiation.
`on_partner_joined`(partner)	Called when a partner joins the negotiation.
`on_partner_left`(partner)	Called when a partner leaves the negotiation.
`on_partner_proposal`(state, partner_id, offer)	A callback called by the mechanism when a partner proposes something
`on_partner_refused_to_propose`(state, partner_id)	A callback called by the mechanism when a partner refuses to propose
`on_partner_response`(state, partner_id, ...)	A callback called by the mechanism when a partner responds to some offer
`on_preferences_changed`(changes)	Called to inform the component that the ufun has changed and the kinds of change that happened.
`on_round_end`(state)	A call back called at each negotiation round end
`on_round_start`(state)	A call back called at each negotiation round start
`propose`(state[, dest])	Propose an offer or None to refuse.
`ready_to_concede`()
`sample_sent`()
`set_negotiator`(negotiator)	Sets the negotiator of which this component is a part.

Attributes Documentation

negotiator

next_indx: int

sorter: PresortingInverseUtilityFunction | None

Methods Documentation

__call__(state: GBState, dest: str | None = None) → Outcome | None[source]: Call self as a function.

after_join(nmi: NegotiatorMechanismInterface) → None: A call back called after joining a negotiation to confirm wwe joined.

after_proposing(state: GBState, offer: Outcome | None, dest: str | None = None): Called after proposing

after_responding(state: GBState, offer: Outcome | None, response: ResponseType, source: str | None = None): Called before offering

before_proposing(state: GBState, dest: str | None = None): Called before proposing

before_responding(state: GBState, offer: Outcome | None, source: str | None = None): Called before offering

best_offer_so_far() → Outcome | None[source]

can_join(nmi: NegotiatorMechanismInterface, state: MechanismState, *, preferences: Preferences | None = None, ufun: BaseUtilityFunction | None = None, role: str = 'negotiator') → bool: A call back called before joining a negotiation to confirm that we can join it.

ensure_sorter()[source]

next_offer() → Outcome | None[source]

on_leave(state: MechanismState) → None: A call back called after leaving a negotiation.

on_mechanism_error(state: MechanismState) → None: A call back called whenever an error happens in the mechanism. The error and its explanation are accessible in state

on_negotiation_end(state: MechanismState) → None: A call back called at each negotiation end

on_negotiation_start(state: MechanismState) → None: A call back called at each negotiation start

on_partner_ended(partner: str)

Called when a partner ends the negotiation.

Note that the negotiator owning this component may never receive this offer. This is only receivd if the mechanism is sending notifications on every offer.

on_partner_joined(partner: str)

Called when a partner joins the negotiation.

This is only receivd if the mechanism is sending notifications.

on_partner_left(partner: str)

Called when a partner leaves the negotiation.

This is only receivd if the mechanism is sending notifications.

on_partner_proposal(state: GBState, partner_id: str, offer: Outcome) → None[source]

A callback called by the mechanism when a partner proposes something

Parameters:

state – MechanismState giving the state of the negotiation when the offer was porposed.
partner_id – The ID of the agent who proposed
offer – The proposal.

Remarks:

Will only be called if enable_callbacks is set for the mechanism

on_partner_refused_to_propose(state: GBState, partner_id: str) → None

A callback called by the mechanism when a partner refuses to propose

Parameters:

state – MechanismState giving the state of the negotiation when the partner refused to offer.
partner_id – The ID of the agent who refused to propose

Remarks:

Will only be called if enable_callbacks is set for the mechanism

on_partner_response(state: GBState, partner_id: str, outcome: Outcome | None, response: ResponseType) → None

A callback called by the mechanism when a partner responds to some offer

Parameters:

state – MechanismState giving the state of the negotiation when the partner responded.
partner_id – The ID of the agent who responded
outcome – The proposal being responded to.
response – The response

Remarks:

Will only be called if enable_callbacks is set for the mechanism

on_preferences_changed(changes: list[PreferencesChange])[source]: Called to inform the component that the ufun has changed and the kinds of change that happened.

on_round_end(state: MechanismState) → None: A call back called at each negotiation round end

on_round_start(state: MechanismState) → None: A call back called at each negotiation round start

propose(state: GBState, dest: str | None = None) → Outcome | None

Propose an offer or None to refuse.

Parameters:

state – GBState giving current state of the negotiation.
dest – the thread in which I am supposed to offer.

Returns:

The outcome being proposed or None to refuse to propose

Remarks:

Caches results for the same thread and step. If called multiple times for the same thread and step, it will do the computations only once.
Caching is useful when the acceptance strategy calls the offering strategy

ready_to_concede() → bool[source]

sample_sent() → Outcome | None[source]

set_negotiator(negotiator: Negotiator) → None: Sets the negotiator of which this component is a part.