Skip to content

aea.skills.base

This module contains the base classes for the skills.

SkillContext Objects

class SkillContext()

This class implements the context of a skill.

__init__

 | __init__(agent_context: Optional[AgentContext] = None, skill: Optional["Skill"] = None) -> None

Initialize a skill context.

:agent_context: the agent context. :skill: the skill.

logger

 | @property
 | logger() -> Logger

Get the logger.

logger

 | @logger.setter
 | logger(logger_: Logger) -> None

Set the logger.

set_agent_context

 | set_agent_context(agent_context: AgentContext) -> None

Set the agent context.

shared_state

 | @property
 | shared_state() -> Dict[str, Any]

Get the shared state dictionary.

agent_name

 | @property
 | agent_name() -> str

Get agent name.

skill_id

 | @property
 | skill_id() -> PublicId

Get the skill id of the skill context.

is_active

 | @property
 | is_active() -> bool

Get the status of the skill (active/not active).

is_active

 | @is_active.setter
 | is_active(value: bool) -> None

Set the status of the skill (active/not active).

new_behaviours

 | @property
 | new_behaviours() -> "Queue[Behaviour]"

Queue for the new behaviours.

This queue can be used to send messages to the framework to request the registration of a behaviour.

:return the queue of new behaviours.

new_handlers

 | @property
 | new_handlers() -> "Queue[Handler]"

Queue for the new handlers.

This queue can be used to send messages to the framework to request the registration of a handler.

:return the queue of new handlers.

agent_addresses

 | @property
 | agent_addresses() -> Dict[str, str]

Get addresses.

agent_address

 | @property
 | agent_address() -> str

Get address.

connection_status

 | @property
 | connection_status() -> MultiplexerStatus

Get connection status.

outbox

 | @property
 | outbox() -> OutBox

Get outbox.

storage

 | @property
 | storage() -> Optional[Storage]

Get optional storage for agent.

message_in_queue

 | @property
 | message_in_queue() -> Queue

Get message in queue.

decision_maker_message_queue

 | @property
 | decision_maker_message_queue() -> Queue

Get message queue of decision maker.

decision_maker_handler_context

 | @property
 | decision_maker_handler_context() -> SimpleNamespace

Get decision maker handler context.

task_manager

 | @property
 | task_manager() -> TaskManager

Get behaviours of the skill.

default_ledger_id

 | @property
 | default_ledger_id() -> str

Get the default ledger id.

currency_denominations

 | @property
 | currency_denominations() -> Dict[str, str]

Get a dictionary mapping ledger ids to currency denominations.

search_service_address

 | @property
 | search_service_address() -> Address

Get the address of the search service.

decision_maker_address

 | @property
 | decision_maker_address() -> Address

Get the address of the decision maker.

handlers

 | @property
 | handlers() -> SimpleNamespace

Get handlers of the skill.

behaviours

 | @property
 | behaviours() -> SimpleNamespace

Get behaviours of the skill.

namespace

 | @property
 | namespace() -> SimpleNamespace

Get the agent context namespace.

__getattr__

 | __getattr__(item: Any) -> Any

Get attribute.

send_to_skill

 | send_to_skill(message_or_envelope: Union[Message, Envelope], context: Optional[EnvelopeContext] = None) -> None

Send message or envelope to another skill.

Arguments:

  • message_or_envelope: envelope to send to another skill. if message passed it will be wrapped into envelope with optional envelope context.

Returns:

None

SkillComponent Objects

class SkillComponent(ABC)

This class defines an abstract interface for skill component classes.

__init__

 | __init__(name: str, skill_context: SkillContext, configuration: Optional[SkillComponentConfiguration] = None, **kwargs: Any, ,) -> None

Initialize a skill component.

Arguments:

  • name: the name of the component.
  • configuration: the configuration for the component.
  • skill_context: the skill context.

name

 | @property
 | name() -> str

Get the name of the skill component.

context

 | @property
 | context() -> SkillContext

Get the context of the skill component.

skill_id

 | @property
 | skill_id() -> PublicId

Get the skill id of the skill component.

configuration

 | @property
 | configuration() -> SkillComponentConfiguration

Get the skill component configuration.

config

 | @property
 | config() -> Dict[Any, Any]

Get the config of the skill component.

setup

 | @abstractmethod
 | setup() -> None

Implement the setup.

Returns:

None

teardown

 | @abstractmethod
 | teardown() -> None

Implement the teardown.

Returns:

None

parse_module

 | @classmethod
 | @abstractmethod
 | parse_module(cls, path: str, configs: Dict[str, SkillComponentConfiguration], skill_context: SkillContext) -> dict

Parse the component module.

AbstractBehaviour Objects

class AbstractBehaviour(SkillComponent,  ABC)

Abstract behaviour for periodical calls.

tick_interval: float, interval to call behaviour's act. start_at: optional datetime, when to start periodical calls.

tick_interval

 | @property
 | tick_interval() -> float

Get the tick_interval in seconds.

start_at

 | @property
 | start_at() -> Optional[datetime.datetime]

Get the start time of the behaviour.

Behaviour Objects

class Behaviour(AbstractBehaviour,  ABC)

This class implements an abstract behaviour.

In a subclass of Behaviour, the flag 'is_programmatically_defined' can be used by the developer to signal to the framework that the class is meant to be used programmatically; hence, in case the class is not declared in the configuration file but it is present in a skill module, the framework will just ignore this class instead of printing a warning message.

act

 | @abstractmethod
 | act() -> None

Implement the behaviour.

Returns:

None

is_done

 | is_done() -> bool

Return True if the behaviour is terminated, False otherwise.

act_wrapper

 | act_wrapper() -> None

Wrap the call of the action. This method must be called only by the framework.

parse_module

 | @classmethod
 | parse_module(cls, path: str, behaviour_configs: Dict[str, SkillComponentConfiguration], skill_context: SkillContext) -> Dict[str, "Behaviour"]

Parse the behaviours module.

Arguments:

  • path: path to the Python module containing the Behaviour classes.
  • behaviour_configs: a list of behaviour configurations.
  • skill_context: the skill context

Returns:

a list of Behaviour.

Handler Objects

class Handler(SkillComponent,  ABC)

This class implements an abstract behaviour.

In a subclass of Handler, the flag 'is_programmatically_defined' can be used by the developer to signal to the framework that the component is meant to be used programmatically; hence, in case the class is not declared in the configuration file but it is present in a skill module, the framework will just ignore this class instead of printing a warning message.

SUPPORTED_PROTOCOL is read by the framework when the handlers are loaded to register them as 'listeners' to the protocol identified by the specified public id. Whenever a message of protocol 'SUPPORTED_PROTOCOL' is sent to the agent, the framework will call the 'handle' method.

handle

 | @abstractmethod
 | handle(message: Message) -> None

Implement the reaction to a message.

Arguments:

  • message: the message

Returns:

None

handle_wrapper

 | handle_wrapper(message: Message) -> None

Wrap the call of the handler. This method must be called only by the framework.

parse_module

 | @classmethod
 | parse_module(cls, path: str, handler_configs: Dict[str, SkillComponentConfiguration], skill_context: SkillContext) -> Dict[str, "Handler"]

Parse the handler module.

Arguments:

  • path: path to the Python module containing the Handler class.
  • handler_configs: the list of handler configurations.
  • skill_context: the skill context

Returns:

an handler, or None if the parsing fails.

Model Objects

class Model(SkillComponent,  ABC)

This class implements an abstract model.

__init__

 | __init__(name: str, skill_context: SkillContext, configuration: Optional[SkillComponentConfiguration] = None, keep_terminal_state_dialogues: Optional[bool] = None, **kwargs: Any, ,) -> None

Initialize a model.

Arguments:

  • name: the name of the component.
  • configuration: the configuration for the component.
  • skill_context: the skill context.
  • keep_terminal_state_dialogues: specify do dialogues in terminal state should stay or not

Returns:

None

setup

 | setup() -> None

Set the class up.

teardown

 | teardown() -> None

Tear the class down.

parse_module

 | @classmethod
 | parse_module(cls, path: str, model_configs: Dict[str, SkillComponentConfiguration], skill_context: SkillContext) -> Dict[str, "Model"]

Parse the model module.

Arguments:

  • path: path to the Python skill module.
  • model_configs: a list of model configurations.
  • skill_context: the skill context

Returns:

a list of Model.

Skill Objects

class Skill(Component)

This class implements a skill.

__init__

 | __init__(configuration: SkillConfig, skill_context: Optional[SkillContext] = None, handlers: Optional[Dict[str, Handler]] = None, behaviours: Optional[Dict[str, Behaviour]] = None, models: Optional[Dict[str, Model]] = None, **kwargs: Any, ,)

Initialize a skill.

Arguments:

  • configuration: the skill configuration.
  • skill_context: the skill context.
  • handlers: dictionary of handlers.
  • behaviours: dictionary of behaviours.
  • models: dictionary of models.

skill_context

 | @property
 | skill_context() -> SkillContext

Get the skill context.

handlers

 | @property
 | handlers() -> Dict[str, Handler]

Get the handlers.

behaviours

 | @property
 | behaviours() -> Dict[str, Behaviour]

Get the handlers.

models

 | @property
 | models() -> Dict[str, Model]

Get the handlers.

from_dir

 | @classmethod
 | from_dir(cls, directory: str, agent_context: AgentContext, **kwargs: Any) -> "Skill"

Load the skill from a directory.

Arguments:

  • directory: the directory to the skill package.
  • agent_context: the skill context

Returns:

the skill object.

logger

 | @property
 | logger() -> Logger

Get the logger.

In the case of a skill, return the logger provided by the skill context.

logger

 | @logger.setter
 | logger(*args: str) -> None

Set the logger.

from_config

 | @classmethod
 | from_config(cls, configuration: SkillConfig, agent_context: AgentContext, **kwargs: Any) -> "Skill"

Load the skill from configuration.

Arguments:

  • configuration: a skill configuration. Must be associated with a directory.
  • agent_context: the agent context.

Returns:

the skill.

_SkillComponentLoadingItem Objects

class _SkillComponentLoadingItem()

Class to represent a triple (component name, component configuration, component class).

__init__

 | __init__(name: str, config: SkillComponentConfiguration, class_: Type[SkillComponent], type_: _SKILL_COMPONENT_TYPES)

Initialize the item.

_SkillComponentLoader Objects

class _SkillComponentLoader()

This class implements the loading policy for skill components.

__init__

 | __init__(configuration: SkillConfig, skill_context: SkillContext, **kwargs: Any)

Initialize the helper class.

load_skill

 | load_skill() -> Skill

Load the skill.