scml.scml2020.components

Submodules

• scml.scml2020.components.negotiation
• scml.scml2020.components.prediction
• scml.scml2020.components.production
• scml.scml2020.components.signing
• scml.scml2020.components.simulation
• scml.scml2020.components.trading

Attributes

__all__

Classes

ProductionStrategy	Represents a strategy for controlling production.
SupplyDrivenProductionStrategy	A production strategy that converts all inputs to outputs
DemandDrivenProductionStrategy	A production strategy that produces ONLY when a contract is secured
TradeDrivenProductionStrategy	A production strategy that produces ONLY for contracts that the agent did not initiate.
TradePredictionStrategy	A prediction strategy for expected inputs and outputs at every step
FixedTradePredictionStrategy	Predicts a fixed amount of trade both for the input and output products.
ExecutionRatePredictionStrategy	A prediction strategy for expected inputs and outputs at every step
FixedERPStrategy	Predicts that the there is a fixed execution rate that does not change for all partners
MeanERPStrategy	Predicts the mean execution fraction for each partner
MarketAwareTradePredictionStrategy	Predicts an amount based on publicly available market information. Falls
SignAll	Signs all contracts no matter what.
SignAllPossible	Signs all contracts that can in principle be honored.
KeepOnlyGoodPrices	Signs all contracts that have good prices
NegotiationManager	A negotiation manager is a component that provides negotiation control functionality to an agent
StepNegotiationManager	A negotiation manager that controls a controller and another for selling for every timestep
IndependentNegotiationsManager	A negotiation manager that manages independent negotiators that do not share any information once created
MovingRangeNegotiationManager	My negotiation strategy
Simulation	Provides a simulator to the agent.

Package Contents

class scml.scml2020.components.ProductionStrategy(*args, **kwargs)

Represents a strategy for controlling production.

Provides:

• schedule_range : A mapping from contract ID to a tuple of the first and last steps at which some lines are occupied to produce the quantity specified by the contract and whether it is a sell contract

• can_be_produced : Given a contract, it returns whether or not it is possible to produce the quantity entailed by it (which means that there is enough vacant production line slots before/after the contracts delivery time for sell/buy contracts).

Hooks Into:

• on_contract_breached

• on_contract_executed

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 Objects Layer 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.

schedule_range: dict[str, tuple[int, int, bool]]

Gives the range of steps at which the production needed for a given contract are scheduled

can_be_produced(contract_id: str)

Returns True if the SELL contract given can be honored in principle given the production capacity of the agent (n. lines). It does not check for the availability of inputs or enough money to run the production process.

Remarks:

• Cannot be called before calling on_contracts_finalized

on_contract_executed(contract: negmas.Contract) → None

on_contract_breached(contract: negmas.Contract, breaches, resolution) → None

class scml.scml2020.components.SupplyDrivenProductionStrategy(*args, **kwargs)

Bases: ProductionStrategy

A production strategy that converts all inputs to outputs

Hooks Into:

• step

• on_contracts_finalized

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 Objects Layer 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.

step()

on_contracts_finalized(signed: list[negmas.Contract], cancelled: list[negmas.Contract], rejectors: list[list[str]]) → None

class scml.scml2020.components.DemandDrivenProductionStrategy(*args, **kwargs)

Bases: ProductionStrategy

A production strategy that produces ONLY when a contract is secured

Hooks Into:

• on_contract_finalized

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 Objects Layer 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.

on_contracts_finalized(signed: list[negmas.Contract], cancelled: list[negmas.Contract], rejectors: list[list[str]]) → None

class scml.scml2020.components.TradeDrivenProductionStrategy(*args, **kwargs)

Bases: ProductionStrategy

A production strategy that produces ONLY for contracts that the agent did not initiate.

Hooks Into:

• on_contract_finalized

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 Objects Layer 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.

on_contracts_finalized(signed: list[negmas.Contract], cancelled: list[negmas.Contract], rejectors: list[list[str]]) → None

class scml.scml2020.components.TradePredictionStrategy(*args, predicted_outputs: int | numpy.ndarray = None, predicted_inputs: int | numpy.ndarray = None, add_trade=False, **kwargs)

A prediction strategy for expected inputs and outputs at every step

Parameters:

• predicted_inputs (-) – None for default, a number of an n_steps numbers giving predicted inputs

• predicted_outputs (-) – None for default, a number of an n_steps numbers giving predicted outputs

Provides:

• expected_inputs : n_steps vector giving the predicted inputs at every time-step. It defaults to the number of lines.

• expected_outputs : n_steps vector giving the predicted outputs at every time-step. It defaults to the number of lines.

• input_cost : n_steps vector giving the predicted input cost at every time-step. It defaults to catalog price.

• output_price : n_steps vector giving the predicted output price at every time-step. It defaults to catalog price.

Hooks Into:

• init

• before_step

• step

Abstract:

• trade_prediction_init: Called during init() to initialize the trade prediction.

• trade_prediction_step: Called during step() to update the trade prediction.

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 Objects Layer 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.

expected_outputs = None

Expected output quantity every step

expected_inputs = None

Expected input quantity every step

input_cost: numpy.ndarray = None

Expected unit price of the input

output_price: numpy.ndarray = None

Expected unit price of the output

_add_trade = False

abstract trade_prediction_init() → None

Will be called to update expected_outputs, expected_inputs, input_cost, output_cost during init()

trade_prediction_before_step() → None

Will be called at the beginning of every step to update the prediction

trade_prediction_step() → None

Will be called at the end of every step to update the prediction

init()

before_step()

step()

class scml.scml2020.components.FixedTradePredictionStrategy(*args, add_trade=True, **kwargs)

Bases: TradePredictionStrategy

Predicts a fixed amount of trade both for the input and output products.

Hooks Into:

• internal_state

• on_contracts_finalized

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 Objects Layer 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.

_add_trade = True

trade_prediction_init()

Will be called to update expected_outputs, expected_inputs, input_cost, output_cost during init()

property internal_state

on_contracts_finalized(signed: List[negmas.Contract], cancelled: List[negmas.Contract], rejectors: List[List[str]]) → None

class scml.scml2020.components.ExecutionRatePredictionStrategy

A prediction strategy for expected inputs and outputs at every step

Provides:

• predict_quantity : A method for predicting the quantity that will actually be executed from a contract

Abstract:

• predict_quantity : A method for predicting the quantity that will actually be executed from a contract

Hooks Into:

• internal_state

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 Objects Layer 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.

abstract predict_quantity(contract: negmas.Contract)

class scml.scml2020.components.FixedERPStrategy(*args, execution_fraction=0.95, **kwargs)

Bases: ExecutionRatePredictionStrategy

Predicts that the there is a fixed execution rate that does not change for all partners

Parameters:

execution_fraction – The expected fraction of any contract’s quantity to be executed

Provides:

• predict_quantity : A method for predicting the quantity that will actually be executed from a contract

Hooks Into:

• internal_state

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 Objects Layer 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.

_execution_fraction = 0.95

predict_quantity(contract: negmas.Contract)

class scml.scml2020.components.MeanERPStrategy(*args, execution_fraction=0.95, **kwargs)

Bases: ExecutionRatePredictionStrategy

Predicts the mean execution fraction for each partner

Parameters:

execution_fraction – The expected fraction of any contract’s quantity to be executed

Provides:

• predict_quantity : A method for predicting the quantity that will actually be executed from a contract

Hooks Into:

• internal_state

• init

• on_contract_executed

• on_contract_breached

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 Objects Layer 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.

_execution_fraction = 0.95

_total_quantity = None

predict_quantity(contract: negmas.Contract)

init()

property internal_state

on_contract_executed(contract: negmas.Contract) → None

on_contract_breached(contract: negmas.Contract, breaches: List[negmas.Breach], resolution: negmas.Contract | None) → None

class scml.scml2020.components.MarketAwareTradePredictionStrategy(*args, predicted_outputs: int | numpy.ndarray = None, predicted_inputs: int | numpy.ndarray = None, add_trade=False, **kwargs)

Bases: TradePredictionStrategy

Predicts an amount based on publicly available market information. Falls back to fixed prediction if no information is available

Hooks Into:

• internal_state

• on_contracts_finalized

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 Objects Layer 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.

init()

trade_prediction_init()

Will be called to update expected_outputs, expected_inputs, input_cost, output_cost during init()

__update()

trade_prediction_step()

Will be called at the end of every step to update the prediction

trade_prediction_before_step()

Will be called at the beginning of every step to update the prediction

property internal_state

class scml.scml2020.components.SignAll

Signs all contracts no matter what.

Overrides:

• sign_all_contracts

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 Objects Layer 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.

sign_all_contracts(contracts: List[negmas.Contract]) → List[str | None]

class scml.scml2020.components.SignAllPossible

Signs all contracts that can in principle be honored. The only check made by this strategy is that for sell contracts there is enough production capacity

Overrides:

• sign_all_contracts

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 Objects Layer 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.

sign_all_contracts(contracts: List[negmas.Contract]) → List[str | None]

class scml.scml2020.components.KeepOnlyGoodPrices(*args, buying_margin=0.5, selling_margin=0.5, **kwargs)

Signs all contracts that have good prices

Overrides:

• sign_all_contracts

- buying_margin

The margin from the catalog price to allow for buying. The agent will never buy at a price higher than the catalog price by more than this margin (relative to catalog price).

- selling_margin

The margin from the catalog price to allow for selling. The agent will never sell at a price lower than the catalog price by more than this margin (relative to catalog price).

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 Objects Layer 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.

sign_all_contracts(contracts: List[negmas.Contract]) → List[str | None]

class scml.scml2020.components.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

Parameters:

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 Objects Layer 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.

_horizon = 5

_negotiate_on_signing = True

_log = False

_use_trading = True

_min_margin = 0.5

_max_margin = 1.5

property use_trading

init()

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

Parameters:

• product – product type. If it is an input product, negotiations to buy it will be started otherweise to sell.

• quantity – The maximum quantity to negotiate about

• unit_price – The maximum/minimum unit price for buy/sell

• step – The maximum/minimum time for buy/sell

• partners – A list of partners to negotiate with

Remarks:

• This method assumes that product is either my_input_product or my_output_product

step()

Generates buy and sell negotiations as needed

on_contracts_finalized(signed: List[negmas.Contract], cancelled: List[negmas.Contract], rejectors: List[List[str]]) → None

_generate_negotiations(step: int, sell: bool) → None

Generates all the required negotiations for selling/buying for the given step

_urange(step, is_seller, time_range)

_trange(step, is_seller)

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

Parameters:

• steps – Simulation step

• sell – Sell or buy

abstract _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

Parameters:

• product – The product to negotiate about.

• sell – If true, this is a sell negotiation

• step – The step

• qvalues – the range of quantities

• uvalues – the range of unit prices

• tvalues – the range of times

• partners – partners

abstract target_quantity(step: int, sell: bool) → int

Returns the target quantity to sell/buy at a given time-step

Parameters:

• step – Simulation step

• sell – Sell or buy

abstract acceptable_unit_price(step: int, sell: bool) → int

Returns the maximum/minimum acceptable unit price for buying/selling at the given time-step

Parameters:

• step – Simulation step

• sell – Sell or buy

abstract respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) → negmas.Negotiator | None

class scml.scml2020.components.StepNegotiationManager(*args, negotiator_type: negmas.SAONegotiator | str = AspirationNegotiator, negotiator_params: Dict[str, Any] | None = None, **kwargs)

Bases: scml.scml2020.components.prediction.MeanERPStrategy, NegotiationManager

A negotiation manager that controls a controller and another for selling for every timestep

Parameters:

• negotiator_type – The negotiator type to use to manage all negotiations

• 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 Objects Layer 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.

negotiator_type

negotiator_params = None

init()

_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

Parameters:

• product – The product to negotiate about.

• sell – If true, this is a sell negotiation

• step – The step

• qvalues – the range of quantities

• uvalues – the range of unit prices

• tvalues – the range of times

• partners – partners

respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) → negmas.Negotiator | None

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

add_controller(is_seller: bool, target, urange: Tuple[int, int], expected_quantity: int, step: int) → scml.scml2020.services.controllers.StepController

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

create_controller(is_seller: bool, target, urange: Tuple[int, int], expected_quantity: int, step: int) → scml.scml2020.services.controllers.StepController

_get_controller(mechanism) → scml.scml2020.services.controllers.StepController

class scml.scml2020.components.IndependentNegotiationsManager(*args, negotiator_type: negmas.SAONegotiator | str = AspirationNegotiator, negotiator_params: Dict[str, Any] | None = None, **kwargs)

Bases: NegotiationManager

A negotiation manager that manages independent negotiators that do not share any information once created

Parameters:

• negotiator_type – The negotiator type to use to manage all negotiations

• 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 Objects Layer 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.

negotiator_type

negotiator_params = None

_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

Parameters:

• product – The product to negotiate about.

• sell – If true, this is a sell negotiation

• step – The step

• qvalues – the range of quantities

• uvalues – the range of unit prices

• tvalues – the range of times

• partners – partners

respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) → negmas.Negotiator | None

create_ufun(is_seller: bool, issues=None, outcomes=None) → negmas.UtilityFunction

Creates a utility function

negotiator(is_seller: bool, issues=None, outcomes=None, partner=None) → negmas.SAONegotiator

Creates a negotiator

class scml.scml2020.components.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

Parameters:

• price_weight – The relative importance of price in the utility calculation.

• utility_threshold – The fraction of maximum utility above which all offers will be accepted.

• time_threshold – The fraction of the negotiation time after which any valid offers will be accepted.

• 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 Objects Layer 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.

index: List[int] = None

time_horizon = 0.1

_time_threshold = 0.9

_price_weight = 0.7

_utility_threshold = 0.9

_min_margin = 0.5

_max_margin = 1.5

controllers: Dict[bool, scml.scml2020.services.controllers.SyncController]

_current_end = -1

_current_start = -1

step()

respond_to_negotiation_request(initiator: str, issues: List[negmas.Issue], annotation: Dict[str, Any], mechanism: negmas.NegotiatorMechanismInterface) → negmas.Negotiator | None

class scml.scml2020.components.Simulation(*args, **kwargs)

Provides a simulator to the agent.

Provides:

• simulator (FactorySimulator): A simulator that can be used to simulate the effect of contracts on the future of the factory

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 Objects Layer 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.

simulator: scml.scml2020.services.FactorySimulator = None

init()

step()

scml.scml2020.components.__all__