This module contains the decision maker class.

class GoalPursuitReadiness()

The goal pursuit readiness.

class Status(Enum)

The enum of the readiness status.

In particular, it can be one of the following:

• Status.READY: when the agent is ready to pursuit its goal
• Status.NOT_READY: when the agent is not ready to pursuit its goal

def __init__() -> None

Instantiate the goal pursuit readiness.

@property
def is_ready() -> bool

Get the readiness.

def update(new_status: Status) -> None

Update the goal pursuit readiness.

Arguments:

• new_status: the new status

class OwnershipState(BaseOwnershipState)

Represent the ownership state of an agent (can proxy a ledger).

def __init__() -> None

Instantiate an ownership state object.

def set(amount_by_currency_id: CurrencyHoldings = None,
        quantities_by_good_id: GoodHoldings = None,
        **kwargs: Any) -> None

Set values on the ownership state.

Arguments:

• amount_by_currency_id: the currency endowment of the agent in this state.
• quantities_by_good_id: the good endowment of the agent in this state.
• kwargs: the keyword arguments.

def apply_delta(delta_amount_by_currency_id: Dict[str, int] = None,
                delta_quantities_by_good_id: Dict[str, int] = None,
                **kwargs: Any) -> None

Apply a state update to the ownership state.

This method is used to apply a raw state update without a transaction.

Arguments:

• delta_amount_by_currency_id: the delta in the currency amounts
• delta_quantities_by_good_id: the delta in the quantities by good
• kwargs: the keyword arguments

@property
def is_initialized() -> bool

Get the initialization status.

@property
def amount_by_currency_id() -> CurrencyHoldings

Get currency holdings in this state.

@property
def quantities_by_good_id() -> GoodHoldings

Get good holdings in this state.

def is_affordable_transaction(terms: Terms) -> bool

Check if the transaction is affordable (and consistent).

E.g. check that the agent state has enough money if it is a buyer or enough holdings if it is a seller. Note, the agent is the sender of the transaction message by design.

Arguments:

• terms: the transaction terms

Returns:

True if the transaction is legal wrt the current state, false otherwise.

def is_affordable(terms: Terms) -> bool

Check if the tx is affordable.

Arguments:

• terms: the transaction terms

Returns:

whether the transaction is affordable or not

def update(terms: Terms) -> None

Update the agent state from a transaction.

Arguments:

• terms: the transaction terms

def apply_transactions(list_of_terms: List[Terms]) -> "OwnershipState"

Apply a list of transactions to (a copy of) the current state.

Arguments:

• list_of_terms: the sequence of transaction terms.

Returns:

the final state.

def __copy__() -> "OwnershipState"

Copy the object.

class Preferences(BasePreferences)

Class to represent the preferences.

def __init__() -> None

Instantiate an agent preference object.

def set(exchange_params_by_currency_id: ExchangeParams = None,
        utility_params_by_good_id: UtilityParams = None,
        **kwargs: Any) -> None

Set values on the preferences.

Arguments:

• exchange_params_by_currency_id: the exchange params.
• utility_params_by_good_id: the utility params for every asset.
• kwargs: the keyword arguments.

@property
def is_initialized() -> bool

Get the initialization status.

Returns:

True if exchange_params_by_currency_id and utility_params_by_good_id are not None.

@property
def exchange_params_by_currency_id() -> ExchangeParams

Get exchange parameter for each currency.

@property
def utility_params_by_good_id() -> UtilityParams

Get utility parameter for each good.

def logarithmic_utility(quantities_by_good_id: GoodHoldings) -> float

Compute agent's utility given her utility function params and a good bundle.

Arguments:

• quantities_by_good_id: the good holdings (dictionary) with the identifier (key) and quantity (value) for each good

Returns:

utility value

def linear_utility(amount_by_currency_id: CurrencyHoldings) -> float

Compute agent's utility given her utility function params and a currency bundle.

Arguments:

• amount_by_currency_id: the currency holdings (dictionary) with the identifier (key) and quantity (value) for each currency

Returns:

utility value

def utility(quantities_by_good_id: GoodHoldings,
            amount_by_currency_id: CurrencyHoldings) -> float

Compute the utility given the good and currency holdings.

Arguments:

• quantities_by_good_id: the good holdings
• amount_by_currency_id: the currency holdings

Returns:

the utility value.

def marginal_utility(
        ownership_state: BaseOwnershipState,
        delta_quantities_by_good_id: Optional[GoodHoldings] = None,
        delta_amount_by_currency_id: Optional[CurrencyHoldings] = None,
        **kwargs: Any) -> float

Compute the marginal utility.

Arguments:

• ownership_state: the ownership state against which to compute the marginal utility.
• delta_quantities_by_good_id: the change in good holdings
• delta_amount_by_currency_id: the change in money holdings
• kwargs: the keyword arguments

Returns:

the marginal utility score

def utility_diff_from_transaction(ownership_state: BaseOwnershipState,
                                  terms: Terms) -> float

Simulate a transaction and get the resulting utility difference (taking into account the fee).

Arguments:

• ownership_state: the ownership state against which to apply the transaction.
• terms: the transaction terms.

Returns:

the score.

def is_utility_enhancing(ownership_state: BaseOwnershipState,
                         terms: Terms) -> bool

Check if the tx is utility enhancing.

Arguments:

• ownership_state: the ownership state against which to apply the transaction.
• terms: the transaction terms

Returns:

whether the transaction is utility enhancing or not

def __copy__() -> "Preferences"

Copy the object.

class DecisionMakerHandler(BaseDecisionMakerHandler)

This class implements the decision maker.

class SigningDialogues(BaseSigningDialogues)

This class keeps track of all oef_search dialogues.

def __init__(self_address: Address, **kwargs: Any) -> None

Initialize dialogues.

Arguments:

• self_address: the address of the entity for whom dialogues are maintained
• kwargs: the keyword arguments

class StateUpdateDialogues(BaseStateUpdateDialogues)

This class keeps track of all oef_search dialogues.

def __init__(self_address: Address, **kwargs: Any) -> None

Initialize dialogues.

Arguments:

• self_address: the address of the entity for whom dialogues are maintained
• kwargs: the keyword arguments

def __init__(identity: Identity, wallet: Wallet, config: Dict[str,
                                                              Any]) -> None

Initialize the decision maker.

Arguments:

• identity: the identity
• wallet: the wallet
• config: the user defined configuration of the handler

def handle(message: Message) -> None

Handle an internal message from the skills.

Arguments:

• message: the internal message