GeniusNegotiator

class negmas.genius.GeniusNegotiator(preferences=None, name=None, parent=None, owner=None, java_class_name=None, domain_file_name=None, utility_file_name=None, can_propose=True, auto_load_java=True, port=25337, genius_bridge_path=None, strict=None, id=None)[source]

Bases: SAONegotiator

Encapsulates a Genius Negotiator

Parameters:

preferences (UtilityFunction | None) – The ufun of the negotiator [optional]
name (str | None) – Negotiator name [optional]
parent (Controller | None) – Parent Controller
owner (Agent) – The agent that owns the negotiator (if any)
java_class_name (str | None) – The java class name of the Geinus underlying agent
domain_file_name (str | Path | None) – Optional domain file name (containing the negotiation issues or agenda)
utility_file_name (str | Path | None) – Optional ufun file name (xml) from which a ufun will be loaded for the agent
can_propose – The negotiator can propose
auto_load_java (bool) – Load the genius bridge if needed
port (int) – The port to load the genius bridge to (or use if it is already loaded)
genius_bridge_path (str | None) – The path to the genius bridge
strict (bool | None) – If True, raise exceptions if any exception is thrown by the agent or the bridge (or if the agent could not choose an action). If false, ignore these exceptions and assume a None return. If None use strict for n_steps limited negotiations and not strict for time_limit limited ones.

Attributes Summary

`ami`
`annotation`	Returns the private information (annotation) not shared with other negotiators
`capabilities`	Agent capabilities
`crisp_ufun`	Returns the preferences if it is a CrispUtilityFunction else None
`has_cardinal_preferences`	Does the entity has an associated ufun?
`has_preferences`	Does the entity has an associated ufun?
`has_ufun`	Does the entity has an associated ufun?
`id`	The unique ID of this entity
`is_connected`
`java_name`
`name`	A convenient name of the entity (intended primarily for printing/logging/debugging).
`nmi`
`opponent_ufun`
`owner`	Returns the owner agent of the negotiator
`parent`	Returns the parent controller
`port`
`preferences`	The utility function attached to that object
`private_info`	Returns the private information (annotation) not shared with other negotiators
`prob_ufun`	Returns the preferences if it is a ProbUtilityFunction else None
`relative_time`
`reserved_outcome`	Reserved outcome is the outcome that will be realized by default for this agent.
`reserved_value`	Reserved value is what the entity gets if no agreement is reached in the negotiation.
`short_type_name`
`strict`
`type_name`
`ufun`	Returns the preferences if it is a `BaseUtilityFunction` else None
`uuid`	The unique ID of this entity

Methods Summary

`__call__`(state)	Called by `Negotiator.__call__` (which is called by the mechanism) to counter the offer.
`add_capabilities`(capabilities)	Adds named capabilities to the negotiator.
`add_handler`(notification_type, callback)	Adds a notification handler to the list of handlers of the given type.
`before_death`(cntxt)	Called whenever the parent is about to kill this negotiator.
`cancel`([reason])	A method that may be called by a mechanism to make the negotiator cancel whatever it is currently processing.
`checkpoint`(path[, file_name, info, ...])	Saves a checkpoint of the current object at the given path.
`checkpoint_info`(file_name)	Returns the information associated with a dump of the object saved in the given file
`create`(args, *kwargs)	Creates an object and returns a proxy to it.
`destroy_java_counterpart`([state])	rtype: `None`
`from_checkpoint`(file_name[, return_info])	Creates an object from a saved checkpoint
`handlers`(notification_type)	Gets the list of handlers registered for some notification type.
`is_acceptable_as_agreement`(outcome)	Whether the given outcome is acceptable as a final agreement of a negotiation.
`isin`(negotiation_id)	Is that agent participating in the given negotiation? Tests if the agent is participating in the given negotiation.
`join`(nmi, state, *[, preferences, ufun, role])	Called by the mechanism when the agent is about to enter a negotiation.
`negotiators`([agent_based, party_based])	Returns a list of all available agents in genius 8.4.0
`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)	called when a negotiation is ended
`on_negotiation_start`(state)	Called when the info starts.
`on_notification`(notification, notifier)	Called whenever a notification is received
`on_notification_`(notification, notifier)	Called when a notification is received.
`on_partner_ended`(partner)	Called when a partner ends the negotiation.
`on_partner_proposal`(state, partner_id, offer)	A callback called by the mechanism when a partner proposes something
`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 entity that its ufun has changed.
`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
`parse`(action)	Parses an action into a ResponseType and an Outcome (if one is included) :type action: `str` :param action:
`propose`(state)	Propose an offer or None to refuse.
`propose_`(state)	The method directly called by the mechanism (through `counter` ) to ask for a proposal
`propose_sao`(state)	rtype: `SAOResponse`
`random_negotiator`([agent_based, ...])	Returns an agent with a random class name
`random_negotiator_name`([agent_based, ...])
`remove_capability`(name)	Removes named capability from the negotiator
`remove_handler`(notification_type, callback)	Removes a notification handler from the list of handlers of the given type.
`respond`(state[, source])	Called to respond to an offer.
`respond_`(state[, source])	The method to be called directly by the mechanism (through `counter` ) to respond to an offer.
`respond_sao`(state)	rtype: `None`
`robust_negotiators`()	Returns a list of genius agents that were tested and seem to be robustly working with negmas
`set_id`(id)	Sets the unique ID of this entity
`set_preferences`(value[, force])	Sets the utility function/Preferences.
`spawn`([spawn_as, spawn_params])
`spawn_object`(args, *kwargs)

Attributes Documentation

ami

annotation: Returns the private information (annotation) not shared with other negotiators

capabilities: Agent capabilities

crisp_ufun: Returns the preferences if it is a CrispUtilityFunction else None

has_cardinal_preferences: Does the entity has an associated ufun?

has_preferences: Does the entity has an associated ufun?

has_ufun: Does the entity has an associated ufun?

id: The unique ID of this entity

is_connected

java_name

name: A convenient name of the entity (intended primarily for printing/logging/debugging).

nmi

opponent_ufun

owner: Returns the owner agent of the negotiator

parent: Returns the parent controller

port

preferences: The utility function attached to that object

private_info: Returns the private information (annotation) not shared with other negotiators

prob_ufun: Returns the preferences if it is a ProbUtilityFunction else None

relative_time

reserved_outcome

Reserved outcome is the outcome that will be realized by default for this agent.

Remarks:

Reserved outcomes are defined for OrdinalPreferences.