scml.scml2020.components.negotiation ==================================== .. py:module:: scml.scml2020.components.negotiation Classes ------- .. autoapisummary:: scml.scml2020.components.negotiation.NegotiationManager scml.scml2020.components.negotiation.StepNegotiationManager scml.scml2020.components.negotiation.IndependentNegotiationsManager scml.scml2020.components.negotiation.MovingRangeNegotiationManager Module Contents --------------- .. py:class:: NegotiationManager(*args, horizon=5, negotiate_on_signing=True, logdebug=False, use_trading_prices=True, min_price_margin=0.5, max_price_margin=0.5, **kwargs) A negotiation manager is a component that provides negotiation control functionality to an agent :param horizon: The number of steps in the future to consider for selling outputs. Provides: - `start_negotiations` An easy to use method to start a set of buy/sell negotiations Requires: - `acceptable_unit_price` - `target_quantity` - OPTIONALLY `target_quantities` Abstract: - `respond_to_negotiation_request` Hooks Into: - `init` - `step` - `on_contracts_finalized` - `respond_to_negotiation_request` Remarks: - `Attributes` section describes the attributes that can be used to construct the component (passed to its `__init__` method). - `Provides` section describes the attributes (methods, properties, data-members) made available by this component directly. Note that everything provided by the bases of this components are also available to the agent (Check the `Bases` section above for all the bases of this component). - `Requires` section describes any requirements from the agent using this component. It defines a set of methods or properties/data-members that must exist in the agent that uses this component. These requirement are usually implemented as abstract methods in the component - `Abstract` section describes abstract methods that MUST be implemented by any descendant of this component. - `Hooks Into` section describes the methods this component overrides calling `super` () which allows other components to hook into the same method (by overriding it). Usually callbacks starting with `on_` are hooked into this way. - `Overrides` section describes the methods this component overrides without calling `super` effectively disallowing any other components after it in the MRO to call this method. Usually methods that do some action (i.e. not starting with `on_`) are overridden this way. .. py:attribute:: _horizon :value: 5 .. py:attribute:: _negotiate_on_signing :value: True .. py:attribute:: _log :value: False .. py:attribute:: _use_trading :value: True .. py:attribute:: _min_margin :value: 0.5 .. py:attribute:: _max_margin :value: 1.5 .. py:property:: use_trading .. py:method:: init() .. py:method:: start_negotiations(product: int, quantity: int, unit_price: int, step: int, partners: List[str] = None) -> None Starts a set of negotiations to buy/sell the product with the given limits :param product: product type. If it is an input product, negotiations to buy it will be started otherweise to sell. :param quantity: The maximum quantity to negotiate about :param unit_price: The maximum/minimum unit price for buy/sell :param step: The maximum/minimum time for buy/sell :param partners: A list of partners to negotiate with Remarks: - This method assumes that product is either my_input_product or my_output_product .. py:method:: step() Generates buy and sell negotiations as needed .. py:method:: on_contracts_finalized(signed: List[negmas.Contract], cancelled: List[negmas.Contract], rejectors: List[List[str]]) -> None .. py:method:: _generate_negotiations(step: int, sell: bool) -> None Generates all the required negotiations for selling/buying for the given step .. py:method:: _urange(step, is_seller, time_range) .. py:method:: _trange(step, is_seller) .. py:method:: target_quantities(steps: Tuple[int, int], sell: bool) -> numpy.ndarray Returns the target quantity to negotiate about for each step in the range given (beginning included and ending excluded) for buying/selling :param steps: Simulation step :param sell: Sell or buy .. py:method:: _start_negotiations(product: int, sell: bool, step: int, qvalues: Tuple[int, int], uvalues: Tuple[int, int], tvalues: Tuple[int, int], partners: List[str]) -> None :abstractmethod: Actually start negotiations with the given agenda :param product: The product to negotiate about. :param sell: If true, this is a sell negotiation :param step: The step :param qvalues: the range of quantities :param uvalues: the range of unit prices :param tvalues: the range of times :param partners: partners .. py:method:: target_quantity(step: int, sell: bool) -> int :abstractmethod: Returns the target quantity to sell/buy at a given time-step :param step: Simulation step :param sell: Sell or buy .. py:method:: acceptable_unit_price(step: int, sell: bool) -> int :abstractmethod: Returns the maximum/minimum acceptable unit price for buying/selling at the given time-step :param step: Simulation step :param sell: Sell or buy .. py:method:: respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) -> Optional[negmas.Negotiator] :abstractmethod: .. py:class:: StepNegotiationManager(*args, negotiator_type: Union[negmas.SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, **kwargs) Bases: :py:obj:`scml.scml2020.components.prediction.MeanERPStrategy`, :py:obj:`NegotiationManager` A negotiation manager that controls a controller and another for selling for every timestep :param negotiator_type: The negotiator type to use to manage all negotiations :param negotiator_params: Paramters of the negotiator Provides: - `all_negotiations_concluded` Requires: - `acceptable_unit_price` - `target_quantity` - OPTIONALLY `target_quantities` Hooks Into: - `init` - `respond_to_negotiation_request` Remarks: - `Attributes` section describes the attributes that can be used to construct the component (passed to its `__init__` method). - `Provides` section describes the attributes (methods, properties, data-members) made available by this component directly. Note that everything provided by the bases of this components are also available to the agent (Check the `Bases` section above for all the bases of this component). - `Requires` section describes any requirements from the agent using this component. It defines a set of methods or properties/data-members that must exist in the agent that uses this component. These requirement are usually implemented as abstract methods in the component - `Abstract` section describes abstract methods that MUST be implemented by any descendant of this component. - `Hooks Into` section describes the methods this component overrides calling `super` () which allows other components to hook into the same method (by overriding it). Usually callbacks starting with `on_` are hooked into this way. - `Overrides` section describes the methods this component overrides without calling `super` effectively disallowing any other components after it in the MRO to call this method. Usually methods that do some action (i.e. not starting with `on_`) are overridden this way. .. py:attribute:: negotiator_type .. py:attribute:: negotiator_params :value: None .. py:method:: init() .. py:method:: _start_negotiations(product: int, sell: bool, step: int, qvalues: Tuple[int, int], uvalues: Tuple[int, int], tvalues: Tuple[int, int], partners: List[str]) -> None Actually start negotiations with the given agenda :param product: The product to negotiate about. :param sell: If true, this is a sell negotiation :param step: The step :param qvalues: the range of quantities :param uvalues: the range of unit prices :param tvalues: the range of times :param partners: partners .. py:method:: respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) -> Optional[negmas.Negotiator] .. py:method:: all_negotiations_concluded(controller_index: int, is_seller: bool) -> None Called by the `StepController` to affirm that it is done negotiating for some time-step .. py:method:: add_controller(is_seller: bool, target, urange: Tuple[int, int], expected_quantity: int, step: int) -> scml.scml2020.services.controllers.StepController .. py:method:: insert_controller(controller: scml.scml2020.services.controllers.StepController, is_seller: bool, target, urange: Tuple[int, int], expected_quantity: int, step: int = None) -> scml.scml2020.services.controllers.StepController .. py:method:: create_controller(is_seller: bool, target, urange: Tuple[int, int], expected_quantity: int, step: int) -> scml.scml2020.services.controllers.StepController .. py:method:: _get_controller(mechanism) -> scml.scml2020.services.controllers.StepController .. py:class:: IndependentNegotiationsManager(*args, negotiator_type: Union[negmas.SAONegotiator, str] = AspirationNegotiator, negotiator_params: Optional[Dict[str, Any]] = None, **kwargs) Bases: :py:obj:`NegotiationManager` A negotiation manager that manages independent negotiators that do not share any information once created :param negotiator_type: The negotiator type to use to manage all negotiations :param negotiator_params: Parameters of the negotiator Requires: - `create_ufun` - `acceptable_unit_price` - `target_quantity` - OPTIONALLY `target_quantities` Hooks Into: - `respond_to_negotiation_request` Remarks: - `Attributes` section describes the attributes that can be used to construct the component (passed to its `__init__` method). - `Provides` section describes the attributes (methods, properties, data-members) made available by this component directly. Note that everything provided by the bases of this components are also available to the agent (Check the `Bases` section above for all the bases of this component). - `Requires` section describes any requirements from the agent using this component. It defines a set of methods or properties/data-members that must exist in the agent that uses this component. These requirement are usually implemented as abstract methods in the component - `Abstract` section describes abstract methods that MUST be implemented by any descendant of this component. - `Hooks Into` section describes the methods this component overrides calling `super` () which allows other components to hook into the same method (by overriding it). Usually callbacks starting with `on_` are hooked into this way. - `Overrides` section describes the methods this component overrides without calling `super` effectively disallowing any other components after it in the MRO to call this method. Usually methods that do some action (i.e. not starting with `on_`) are overridden this way. .. py:attribute:: negotiator_type .. py:attribute:: negotiator_params :value: None .. py:method:: _start_negotiations(product: int, sell: bool, step: int, qvalues: Tuple[int, int], uvalues: Tuple[int, int], tvalues: Tuple[int, int], partners: List[str]) -> None Actually start negotiations with the given agenda :param product: The product to negotiate about. :param sell: If true, this is a sell negotiation :param step: The step :param qvalues: the range of quantities :param uvalues: the range of unit prices :param tvalues: the range of times :param partners: partners .. py:method:: respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) -> Optional[negmas.Negotiator] .. py:method:: create_ufun(is_seller: bool, issues=None, outcomes=None) -> negmas.UtilityFunction Creates a utility function .. py:method:: negotiator(is_seller: bool, issues=None, outcomes=None, partner=None) -> negmas.SAONegotiator Creates a negotiator .. py:class:: MovingRangeNegotiationManager(*args, price_weight=0.7, utility_threshold=0.9, time_threshold=0.9, time_horizon=0.1, min_price_margin=0.5, max_price_margin=0.5, **kwargs) My negotiation strategy :param price_weight: The relative importance of price in the utility calculation. :param utility_threshold: The fraction of maximum utility above which all offers will be accepted. :param time_threshold: The fraction of the negotiation time after which any valid offers will be accepted. :param time_range: The time-range for each controller as a fraction of the number of simulation steps Hooks Into: - `init` - `step` Remarks: - `Attributes` section describes the attributes that can be used to construct the component (passed to its `__init__` method). - `Provides` section describes the attributes (methods, properties, data-members) made available by this component directly. Note that everything provided by the bases of this components are also available to the agent (Check the `Bases` section above for all the bases of this component). - `Requires` section describes any requirements from the agent using this component. It defines a set of methods or properties/data-members that must exist in the agent that uses this component. These requirement are usually implemented as abstract methods in the component - `Abstract` section describes abstract methods that MUST be implemented by any descendant of this component. - `Hooks Into` section describes the methods this component overrides calling `super` () which allows other components to hook into the same method (by overriding it). Usually callbacks starting with `on_` are hooked into this way. - `Overrides` section describes the methods this component overrides without calling `super` effectively disallowing any other components after it in the MRO to call this method. Usually methods that do some action (i.e. not starting with `on_`) are overridden this way. .. py:attribute:: index :type: List[int] :value: None .. py:attribute:: time_horizon :value: 0.1 .. py:attribute:: _time_threshold :value: 0.9 .. py:attribute:: _price_weight :value: 0.7 .. py:attribute:: _utility_threshold :value: 0.9 .. py:attribute:: _min_margin :value: 0.5 .. py:attribute:: _max_margin :value: 1.5 .. py:attribute:: controllers :type: Dict[bool, scml.scml2020.services.controllers.SyncController] .. py:attribute:: _current_end :value: -1 .. py:attribute:: _current_start :value: -1 .. py:method:: step() .. py:method:: respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) -> Optional[negmas.Negotiator]