def update(self, message: Message) -> bool:
"""
Extend the list of incoming/outgoing messages with 'message', if 'message' is valid.
:param message: a message to be added
:return: True if message successfully added, false otherwise
"""
if (message.is_incoming and self.last_message is not None
and self.last_message.message_id == self.STARTING_MESSAGE_ID
and self.dialogue_label.dialogue_reference[1]
== self.OPPONENT_STARTER_REFERENCE):
self._update_self_initiated_dialogue_label_on_second_message(
message)
counterparty = None # type: Optional[str]
try:
counterparty = message.counterparty
except AssertionError:
message.counterparty = self.dialogue_label.dialogue_opponent_addr
if counterparty is not None:
assert (
message.counterparty ==
self.dialogue_label.dialogue_opponent_addr
), "The counterparty specified in the message is different from the opponent in this dialogue."
is_extendable = self.is_valid_next_message(message)
if is_extendable:
if message.is_incoming:
self._incoming_messages.extend([message])
else:
self._outgoing_messages.extend([message])
return is_extendable
def test_envelope_initialisation():
"""Testing the envelope initialisation."""
agent_address = "Agent0"
receiver_address = "Agent1"
msg = Message(content="hello")
msg.counterparty = receiver_address
assert Envelope(
to=receiver_address,
sender=agent_address,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
), "Cannot generate a new envelope"
envelope = Envelope(
to=receiver_address,
sender=agent_address,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
)
envelope.to = "ChangedAgent"
envelope.sender = "ChangedSender"
envelope.protocol_id = "my_changed_protocol"
envelope.message = b"HelloWorld"
assert envelope.to == "ChangedAgent", "Cannot set to value on Envelope"
assert envelope.sender == "ChangedSender", "Cannot set sender value on Envelope"
assert (
envelope.protocol_id == "my_changed_protocol"
), "Cannot set protocol_id on Envelope "
assert envelope.message == b"HelloWorld", "Cannot set message on Envelope"
assert envelope.context.uri_raw is not None
def handle(self, message: Message) -> None:
"""
Handle an internal message from the skills.
:param message: the internal message
:return: None
"""
message.counterparty = uuid4().hex # TODO: temporary fix only
message.is_incoming = True
self.decision_maker_handler.handle(message)
def handle(self, message: Message) -> None:
"""
Implement the reaction to a message.
:param message: the message
:return: None
"""
self.dialogue.update(message)
self.handled_message = message
message.counterparty = self.dialogue.dialogue_label.dialogue_opponent_addr
self.dialogue.update(self.message_2)
self.context.outbox.put_message(self.message_2)
def update(self, message: Message) -> Optional[Dialogue]:
"""
Update the state of dialogues with a new incoming message.
If the message is for a new dialogue, a new dialogue is created with 'message' as its first message, and returned.
If the message is addressed to an existing dialogue, the dialogue is retrieved, extended with this message and returned.
If there are any errors, e.g. the message dialogue reference does not exists or the message is invalid w.r.t. the dialogue, return None.
:param message: a new message
:return: the new or existing dialogue the message is intended for, or None in case of any errors.
"""
dialogue_reference = message.dialogue_reference
if ( # new dialogue by other
dialogue_reference[0] != "" and dialogue_reference[1] == ""
and message.is_incoming):
dialogue = self._create_opponent_initiated(
dialogue_opponent_addr=message.counterparty,
dialogue_reference=dialogue_reference,
role=self._role_from_first_message(message),
) # type: Optional[Dialogue]
elif ( # new dialogue by self
dialogue_reference[0] != "" and dialogue_reference[1] == ""
and not message.is_incoming):
assert (
message.counterparty is not None
), "The message counter-party field is not set {}".format(message)
dialogue = self._create_self_initiated(
dialogue_opponent_addr=message.counterparty,
role=self._role_from_first_message(message),
)
else: # existing dialogue
self._update_self_initiated_dialogue_label_on_second_message(
message)
dialogue = self.get_dialogue(message)
if dialogue is not None:
if message.counterparty is None:
message.counterparty = dialogue.dialogue_label.dialogue_opponent_addr
else:
assert (
message.counterparty ==
dialogue.dialogue_label.dialogue_opponent_addr
), "The counterparty specified in the message is different from the opponent in this dialogue."
dialogue.update(message)
result = dialogue # type: Optional[Dialogue]
else: # couldn't find the dialogue
result = None
return result
def dummy_envelope(
cls,
to: str = "test",
sender: str = "test",
protocol_id: ProtocolId = DefaultMessage.protocol_id,
message: Message = None,
) -> Envelope:
"""
Create envelope, if message is not passed use .dummy_message method.
:return: Envelope
"""
message = message or cls.dummy_default_message()
message.counterparty = to
return Envelope(to=to, sender=sender, protocol_id=protocol_id, message=message,)
def test_inbox_nowait():
"""Tests the inbox without waiting."""
agent_address = "Agent0"
receiver_address = "Agent1"
msg = Message(content="hello")
msg.counterparty = receiver_address
multiplexer = Multiplexer([_make_dummy_connection()])
envelope = Envelope(
to=receiver_address,
sender=agent_address,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
)
multiplexer.in_queue.put(envelope)
inbox = InBox(multiplexer)
assert (inbox.get_nowait() == envelope
), "Check for a message on the in queue and wait for no time."
def test_inbox_get():
"""Tests for a envelope on the in queue."""
agent_address = "Agent0"
receiver_address = "Agent1"
msg = Message(content="hello")
msg.counterparty = receiver_address
multiplexer = Multiplexer([_make_dummy_connection()])
envelope = Envelope(
to=receiver_address,
sender=agent_address,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
)
multiplexer.in_queue.put(envelope)
inbox = InBox(multiplexer)
assert (
inbox.get() == envelope
), "Checks if the returned envelope is the same with the queued envelope."
def ensure_counterparty(self, message: Message) -> None:
"""
Ensure the counterparty is set (set if not) correctly.
:param message: a message
:return: None
"""
counterparty = None # type: Optional[str]
try:
counterparty = message.counterparty
except AssertionError:
# assume message belongs to dialogue
message.counterparty = self.dialogue_label.dialogue_opponent_addr
if counterparty is not None:
assert (
message.counterparty ==
self.dialogue_label.dialogue_opponent_addr
), "The counterparty specified in the message is different from the opponent in this dialogue."
