def __init__(self,
name: str,
connections: List[Connection],
wallet: Wallet,
loop: Optional[AbstractEventLoop] = None,
timeout: float = 1.0,
debug: bool = False) -> None:
"""
Instantiate the agent.
:param name: the name of the agent
:param connections: the list of connections of the agent.
:param wallet: the crypto wallet of the agent.
:param loop: the event loop to run the connections.
:param timeout: the time in (fractions of) seconds to time out an agent between act and react
:param debug: if True, run the agent in debug mode.
:return: None
"""
self._name = name
self._connections = connections
self._wallet = wallet
self._multiplexer = Multiplexer(self._connections, loop=loop)
self._inbox = InBox(self._multiplexer)
self._outbox = OutBox(self._multiplexer)
self._liveness = Liveness()
self._timeout = timeout
self.debug = debug
def __init__(
self,
identity: Identity,
connections: List[Connection],
loop: Optional[AbstractEventLoop] = None,
timeout: float = 1.0,
is_debug: bool = False,
loop_mode: Optional[str] = None,
) -> None:
"""
Instantiate the agent.
:param identity: the identity of the agent.
:param connections: the list of connections of the agent.
:param loop: the event loop to run the connections.
:param timeout: the time in (fractions of) seconds to time out an agent between act and react
:param is_debug: if True, run the agent in debug mode (does not connect the multiplexer).
:param loop_mode: loop_mode to choose agent run loop.
:return: None
"""
self._identity = identity
self._connections = connections
self._multiplexer = Multiplexer(self._connections, loop=loop)
self._inbox = InBox(self._multiplexer)
self._outbox = OutBox(self._multiplexer)
self._liveness = Liveness()
self._timeout = timeout
self._tick = 0
self._main_loop: Optional[BaseAgentLoop] = None
self.is_debug = is_debug
self._loop_mode = loop_mode or self.DEFAULT_RUN_LOOP
def test_inbox_get_nowait_returns_none():
"""Test that getting an envelope from an empty inbox returns None."""
# TODO get_nowait in this case should raise an exception, like it's done in queue.Queue
multiplexer = Multiplexer(
[DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)])
inbox = InBox(multiplexer)
assert inbox.get_nowait() is None
def test_outbox_put():
"""Tests that an envelope is putted into the queue."""
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
message_bytes = DefaultSerializer().encode(msg)
multiplexer = Multiplexer(
[DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)])
outbox = OutBox(multiplexer)
inbox = InBox(multiplexer)
multiplexer.connect()
envelope = Envelope(
to="Agent1",
sender="Agent0",
protocol_id=DefaultMessage.protocol_id,
message=message_bytes,
)
outbox.put(envelope)
time.sleep(0.5)
assert not inbox.empty(
), "Inbox must not be empty after putting an envelope"
multiplexer.disconnect()
def __init__(
self,
identity: Identity,
connections: List[Connection],
loop: Optional[AbstractEventLoop] = None,
timeout: float = 1.0,
is_debug: bool = False,
is_programmatic: bool = True, # TODO to remove
) -> None:
"""
Instantiate the agent.
:param identity: the identity of the agent.
:param connections: the list of connections of the agent.
:param loop: the event loop to run the connections.
:param timeout: the time in (fractions of) seconds to time out an agent between act and react
:param is_debug: if True, run the agent in debug mode (does not connect the multiplexer).
:param is_programmatic: if True, run the agent in programmatic mode (skips loading of resources from directory).
:return: None
"""
self._identity = identity
self._connections = connections
self._multiplexer = Multiplexer(self._connections, loop=loop)
self._inbox = InBox(self._multiplexer)
self._outbox = OutBox(self._multiplexer)
self._liveness = Liveness()
self._timeout = timeout
self._tick = 0
self.is_debug = is_debug
def test_filtered_search_result(self):
"""Test that the search result contains only the entries matching the query."""
request_id = 1
query = Query(constraints=[], model=self.data_model_barfoo)
# build and send the request
search_services_request = OefSearchMessage(
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
dialogue_reference=(str(request_id), ""),
query=query,
)
msg_bytes = OefSearchSerializer().encode(search_services_request)
envelope = Envelope(
to=DEFAULT_OEF,
sender=self.address_1,
protocol_id=OefSearchMessage.protocol_id,
message=msg_bytes,
)
self.multiplexer1.put(envelope)
# check the result
response_envelope = InBox(self.multiplexer1).get(block=True, timeout=5.0)
assert response_envelope.protocol_id == OefSearchMessage.protocol_id
assert response_envelope.to == self.address_1
assert response_envelope.sender == DEFAULT_OEF
search_result = OefSearchSerializer().decode(response_envelope.message)
assert search_result.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert search_result.agents == (self.address_2,)
def test_inbox_get_raises_exception_when_empty():
"""Test that getting an envelope from an empty inbox raises an exception."""
multiplexer = Multiplexer([DummyConnection()])
inbox = InBox(multiplexer)
with pytest.raises(aea.mail.base.Empty):
with unittest.mock.patch.object(multiplexer, "get", return_value=None):
inbox.get()
def test_inbox_nowait():
"""Tests the inbox without waiting."""
msg = Message(content="hello")
message_bytes = ProtobufSerializer().encode(msg)
multiplexer = Multiplexer([DummyConnection()])
envelope = Envelope(to="Agent1",
sender="Agent0",
protocol_id="my_own_protocol",
message=message_bytes)
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_outbox_put_message():
"""Tests that an envelope is created from the message is in the queue."""
msg = DefaultMessage(type=DefaultMessage.Type.BYTES, content=b"hello")
message_bytes = DefaultSerializer().encode(msg)
multiplexer = Multiplexer([DummyConnection()])
outbox = OutBox(multiplexer)
inbox = InBox(multiplexer)
multiplexer.connect()
outbox.put_message("Agent1", "Agent0", DefaultMessage.protocol_id,
message_bytes)
time.sleep(0.5)
assert not inbox.empty(
), "Inbox will not be empty after putting a message."
multiplexer.disconnect()
def test_inbox_get():
"""Tests for a envelope on the in queue."""
msg = Message(content="hello")
message_bytes = ProtobufSerializer().encode(msg)
multiplexer = Multiplexer([DummyConnection()])
envelope = Envelope(to="Agent1",
sender="Agent0",
protocol_id="my_own_protocol",
message=message_bytes)
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 test_inbox_get():
"""Tests for a envelope on the in queue."""
msg = Message(content="hello")
message_bytes = ProtobufSerializer().encode(msg)
my_queue = Queue()
envelope = Envelope(to="Agent1",
sender="Agent0",
protocol_id="my_own_protocol",
message=message_bytes)
my_queue.put(envelope)
_inbox = InBox(my_queue)
assert _inbox.get() == envelope,\
"Checks if the returned envelope is the same with the queued envelope."
def test_inbox_nowait():
"""Tests the inbox without waiting."""
msg = Message(content="hello")
message_bytes = ProtobufSerializer().encode(msg)
multiplexer = Multiplexer([_make_dummy_connection()])
envelope = Envelope(
to="Agent1",
sender="Agent0",
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=message_bytes,
)
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."""
msg = Message(content="hello")
message_bytes = ProtobufSerializer().encode(msg)
multiplexer = Multiplexer([_make_dummy_connection()])
envelope = Envelope(
to="Agent1",
sender="Agent0",
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=message_bytes,
)
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 test_outbox_put():
"""Tests that an envelope is putted into the queue."""
msg = DefaultMessage(type=DefaultMessage.Type.BYTES, content=b"hello")
message_bytes = DefaultSerializer().encode(msg)
multiplexer = Multiplexer([DummyConnection()])
outbox = OutBox(multiplexer)
inbox = InBox(multiplexer)
multiplexer.connect()
envelope = Envelope(to="Agent1",
sender="Agent0",
protocol_id=DefaultMessage.protocol_id,
message=message_bytes)
outbox.put(envelope)
time.sleep(0.5)
assert not inbox.empty(
), "Inbox must not be empty after putting an envelope"
multiplexer.disconnect()
def test_filtered_search_result(self):
"""Test that the search result contains only the entries matching the query."""
request_id = 1
query = Query(constraints=[], model=self.data_model_barfoo)
# build and send the request
search_services_request = OEFMessage(oef_type=OEFMessage.Type.SEARCH_SERVICES, id=request_id, query=query)
msg_bytes = OEFSerializer().encode(search_services_request)
envelope = Envelope(to=DEFAULT_OEF, sender=self.public_key_1, protocol_id=OEFMessage.protocol_id,
message=msg_bytes)
self.multiplexer1.put(envelope)
# check the result
response_envelope = InBox(self.multiplexer1).get(block=True, timeout=5.0)
assert response_envelope.protocol_id == OEFMessage.protocol_id
assert response_envelope.to == self.public_key_1
assert response_envelope.sender == DEFAULT_OEF
search_result = OEFSerializer().decode(response_envelope.message)
assert search_result.get("type") == OEFMessage.Type.SEARCH_RESULT
assert search_result.get("agents") == [self.public_key_2]
def test_outbox_put_message():
"""Tests that an envelope is created from the message is in the queue."""
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
message_bytes = DefaultSerializer().encode(msg)
dummy_connection = _make_dummy_connection()
multiplexer = Multiplexer([dummy_connection])
outbox = OutBox(multiplexer)
inbox = InBox(multiplexer)
multiplexer.connect()
outbox.put_message("Agent1", "Agent0", DefaultMessage.protocol_id,
message_bytes)
time.sleep(0.5)
assert not inbox.empty(
), "Inbox will not be empty after putting a message."
multiplexer.disconnect()
def test_inbox_get_nowait_returns_none():
"""Test that getting an envelope from an empty inbox returns None."""
# TODO get_nowait in this case should raise an exception, like it's done in queue.Queue
multiplexer = Multiplexer([_make_dummy_connection()])
inbox = InBox(multiplexer)
assert inbox.get_nowait() is None
def test_inbox_empty():
"""Tests if the inbox is empty."""
my_queue = Queue()
_inbox = InBox(my_queue)
assert _inbox.empty(), "Inbox is not empty"
def test_inbox_empty():
"""Tests if the inbox is empty."""
multiplexer = Multiplexer(
[DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)])
_inbox = InBox(multiplexer)
assert _inbox.empty(), "Inbox is not empty"
def test_inbox_empty():
"""Tests if the inbox is empty."""
multiplexer = Multiplexer([DummyConnection()])
_inbox = InBox(multiplexer)
assert _inbox.empty(), "Inbox is not empty"