def setup(self):
print(f"[{self.jid}] Hello World! I'm agent {self.jid}")
# Update topology - waiting for request from manager
template_msg = Template()
template_msg.sender = self.manager_jid
template_msg.set_metadata('performative', 'request')
self.add_behaviour(UpdateTopology(period=config.UPDATE_TOPOLOGY_FREQ),
template_msg)
# Handler for subscribe request
template_msg = Template()
template_msg.set_metadata('performative', 'subscribe')
self.add_behaviour(Subscribe(), template_msg)
# Reporting to manager
self.add_behaviour(
SendReportForSubscribers(period=config.SEND_REPORT_FREQ))
# Get data from sensors
self.add_behaviour(GetCars(period=config.GET_DATA_FREQ))
self.add_behaviour(GetLightsStatus(period=config.GET_DATA_FREQ))
# Control lights
#self.add_behaviour(ChangeLights(config.CHANGE_LIGHTS_FREQ))
# Answering protocol
self.add_behaviour(
CrossroadsMessanger.NegotiatingProtocolParticipant())
self.add_behaviour(CrossroadsMessanger.NegotiatingProtocolInitiator())
async def setup(self):
"""Executed when the agent starts."""
logger.info("CheffAgent starting . . .")
# Ingredients names
with open((COMMON_DIR / 'ingredients_es.csv'), 'r') as f: # classes
self.INGREDIENTS = list(csv.reader(f))[0]
logger.debug(self.INGREDIENTS)
# User list of ingredients
# self.list_ingred = lil_matrix((1, len(self.INGREDIENTS)), dtype=bool)
self.reset_list_ingred()
# Matrix of ingreds_recipes
self.ingreds_recipes = csc_matrix(
np.genfromtxt((COMMON_DIR / 'ingreds_recipes.csv'),
dtype=np.int8,
delimiter=','))
# User preferences on ingredients
self.preferences = None
i = self.AddIngredBehaviour()
c = self.CookBehaviour()
m = self.MissingBehaviour()
p = self.PreferencesBehaviour()
t_i = Template()
t_i.set_metadata("performative", "inform")
t_c = Template()
t_c.set_metadata("performative", "request")
t_m = Template()
t_m.set_metadata("performative", "query_ref")
t_p = Template()
t_p.set_metadata("performative", "inform_ref")
self.add_behaviour(i, t_i)
self.add_behaviour(m, t_m)
self.add_behaviour(c, t_c)
self.add_behaviour(p, t_p)
async def handleResponse(self,
result: Optional[Sequence[DFAgentDescription]]):
self.agent._slot_manager_agents_jids = [
SlotJid(x.service.properties['slot_id'], x.agentName)
for x in result
]
allocation_mt = Template()
allocation_mt.set_metadata('protocol', 'ContractNet')
allocation_mt.set_metadata('action', AllocationRequest.__key__)
reallocation_mt = Template()
reallocation_mt.set_metadata('protocol', 'Request')
reallocation_mt.set_metadata('action', ReallocationRequest.__key__)
deallocation_mt = Template()
deallocation_mt.set_metadata('protocol', 'Request')
deallocation_mt.set_metadata('action', DeallocationRequest.__key__)
self.agent.log(f'Found slot managers')
self.agent.add_behaviour(DeallocationResponder(), deallocation_mt)
self.agent.add_behaviour(
AllocationInitiator(self.agent.available_slots_jids),
allocation_mt)
self.agent.add_behaviour(ReallocationResponder(), reallocation_mt)
async def setup(self):
if runtime_switches.log_level >= 0:
print(str(self.jid) + " Central agent setup")
self.date = datetime.now()
datetime_inform_template = Template()
datetime_inform_template.set_metadata('performative', 'inform')
datetime_inform_template.set_metadata("type", "datetime_inform")
datetime_behaviour = self.ReceiveDatetimeInformBehaviour()
self.add_behaviour(datetime_behaviour, datetime_inform_template)
meeting_request_template = Template()
meeting_request_template.set_metadata('type', 'meet_request')
meeting_request_template.set_metadata('performative', 'request')
booking_behaviour = self.MeetingBookingBehaviour()
self.add_behaviour(booking_behaviour, meeting_request_template)
meeting_score_template = Template()
meeting_score_template.set_metadata('type', 'meeting_score_inform')
meeting_score_template.set_metadata('performative', 'inform')
self.add_behaviour(self.ReceiveScoreBehaviour(),
meeting_score_template)
meeting_late_template = Template()
meeting_late_template.set_metadata('performative', 'inform')
meeting_late_template.set_metadata('type', 'late')
meeting_late_behaviour = self.MeetingLateBehaviour()
self.add_behaviour(meeting_late_behaviour, meeting_late_template)
async def setup(self):
self.total_busy_time = 0.0
logger.info("Station agent {} running".format(self.name))
self.set_type("station")
self.set_status()
try:
template = Template()
template.set_metadata("protocol", REGISTER_PROTOCOL)
register_behaviour = RegistrationBehaviour()
self.add_behaviour(register_behaviour, template)
while not self.has_behaviour(register_behaviour):
logger.warning(
"Station {} could not create RegisterBehaviour. Retrying..."
.format(self.agent_id))
self.add_behaviour(register_behaviour, template)
except Exception as e:
logger.error(
"EXCEPTION creating RegisterBehaviour in Station {}: {}".
format(self.agent_id, e))
try:
template = Template()
template.set_metadata("protocol", TRAVEL_PROTOCOL)
travel_behaviour = TravelBehaviour()
self.add_behaviour(travel_behaviour, template)
while not self.has_behaviour(travel_behaviour):
logger.warning(
"Customer {} could not create TravelBehaviour. Retrying..."
.format(self.agent_id))
self.add_behaviour(travel_behaviour, template)
except Exception as e:
logger.error(
"EXCEPTION creating TravelBehaviour in Station {}: {}".format(
self.agent_id, e))
self.ready = True
async def run(self):
msg = await self.receive(timeout=1000000)
if msg is None:
print("[" + self.agent.name + "]: Warning! Cannot begin")
self.agent.stop()
return
else:
tokens = msg.body.split()
s_map_name = None
for token in tokens:
if token == "MAP:":
s_map_name = tokens[tokens.index(token) + 1]
print("[" + self.agent.name + "]: Beginning to fight")
if not s_map_name:
return
self.agent.m_Map = CTerrainMap()
config = CConfig()
self.agent.m_Map.LoadMap(s_map_name, config)
self.agent.m_Movement = CMobile()
self.agent.m_Movement.SetSize(self.agent.m_Map.GetSizeX(),
self.agent.m_Map.GetSizeZ())
self.agent.generate_spawn_position()
self.agent.SetUpPriorities()
# Behaviour to get the objective of the game, to create the corresponding task
t = Template()
t.set_metadata("performative", "objective")
self.agent.add_behaviour(self.agent.ObjectiveBehaviour(), t)
# Behaviour to listen to manager if game has finished
t = Template()
t.set_metadata("performative", "game")
self.agent.add_behaviour(self.agent.GameFinishedBehaviour(), t)
# Behaviour to handle Pack Taken messages
t = Template()
t.set_metadata("performative", "pack_taken")
self.agent.add_behaviour(self.agent.PackTakenBehaviour(0), t)
# Behaviour to handle Shot messages
t = Template()
t.set_metadata("performative", "shot")
self.agent.add_behaviour(self.agent.PackTakenBehaviour(0), t)
# Behaviour to inform JGomasManager our position, status, and so on
self.agent.add_behaviour(
self.agent.DataFromTroopBehaviour(0.1))
# Behaviour to increment inner variables (Power, Stamina and Health Bars)
#self.agent.Launch_BarsAddOn_InnerBehaviour()
self.agent.add_behaviour(self.agent.RestoreBehaviour(1))
# Behaviour to call for medics or fieldops
self.agent.add_behaviour(
self.agent.MedicAmmoRequestBehaviour(1))
# // Behaviour to launch the FSM
self.agent.Launch_FSM_Behaviour()
async def setup(self):
template = Template(metadata={"performative": "Modify"})
self.add_behaviour(self.Modify(period=5, start_at=datetime.now()),
template)
template = Template(metadata={"performative": "Ending"})
self.add_behaviour(
self.Behav4(start_at=datetime.now() + timedelta(seconds=11)),
template)
async def setup(self):
self.classifierJID = list()
self.clusteringJID = list()
newConnection = Template()
newConnection.set_metadata("performative", "new_connection")
askTemplate = Template()
askTemplate.set_metadata("performative", "ask")
self.add_behaviour(self.NewConnection(), newConnection)
self.add_behaviour(self.RespondBehaviour(), askTemplate)
def setup(self):
self.web.start(templates_path="examples")
template1 = Template(sender="agent0@fake_server")
template2 = Template(sender="agent1@fake_server")
template3 = Template(sender="agent2@fake_server")
template4 = Template(sender="agent3@fake_server")
# Create some dummy behaviours
dummybehav = self.DummyBehav()
self.add_behaviour(dummybehav, template=template1)
periodbehav = self.DummyPeriodBehav(period=12.7)
self.add_behaviour(periodbehav, template=template2)
timeoutbehav = self.DummyTimeoutBehav(start_at=datetime.datetime.now())
self.add_behaviour(timeoutbehav, template=template3)
fsm_behav = self.DummyFSMBehav()
self.add_behaviour(fsm_behav, template=template4)
behavs = [dummybehav, periodbehav, timeoutbehav, fsm_behav]
# Create some fake contacts
self.add_fake_contact("agent0@fake_server", PresenceType.AVAILABLE)
self.add_fake_contact("agent1@fake_server",
PresenceType.AVAILABLE,
show=PresenceShow.AWAY)
self.add_fake_contact(
"agent2@fake_server",
PresenceType.AVAILABLE,
show=PresenceShow.DO_NOT_DISTURB,
)
self.add_fake_contact("agent3@fake_server", PresenceType.UNAVAILABLE)
self.add_fake_contact("agent4@fake_server",
PresenceType.AVAILABLE,
show=PresenceShow.CHAT)
self.add_fake_contact("agent5@fake_server", PresenceType.UNAVAILABLE)
# Send and Receive some fake messages
self.traces.reset()
for i in range(20):
number = random.randint(0, 3)
from_ = JID.fromstr("agent{}@fake_server".format(number))
msg = aioxmpp.Message(from_=from_,
to=self.jid,
type_=MessageType.CHAT)
msg.body[None] = "Hello from {}! This is a long message.".format(
from_.localpart)
msg = Message.from_node(msg)
msg.metadata = {
"performative": "inform",
"acl-representation": "xml"
}
msg = msg.prepare()
self._message_received(msg=msg)
msg = Message(sender=str(self.jid),
to=str(from_),
body="This is my answer.")
msg.sent = True
self.traces.append(msg, category=str(behavs[number]))
def setup(self):
tmp = Template()
tmp.set_metadata("stream", "ta_result")
ba = DecisionAgentBehaviour()
self.add_behaviour(ba, template=tmp)
tmp = Template()
tmp.set_metadata("stream", "high_alert_result")
ba = HighAlertNewsRecBehaviour()
self.add_behaviour(ba, template=tmp)
async def setup(self):
LogManager.log(self.name, "StatisticalAgent starting...")
t1 = Template(metadata={"performative": "temp"})
t2 = Template(metadata={"performative": "query"})
stat_presence_behav = self.PresenceNotificationBehav(1)
time_rec_behav = self.TimeReceiverBehav(1)
statistic_behav = self.StatisticalBehav(1)
self.add_behaviour(stat_presence_behav)
self.add_behaviour(time_rec_behav, t1)
self.add_behaviour(statistic_behav, t2)
async def setup(self):
sensorMessageTemplate = Template()
sensorMessageTemplate.set_metadata("performative", "malfunction")
sensorMessageTemplate.set_metadata("ontology", "device")
self.add_behaviour(ReceiveSensorMessagesBehaviour(), template=sensorMessageTemplate)
bidMessageTemplate = Template()
bidMessageTemplate.set_metadata("performative", "bid")
bidMessageTemplate.set_metadata("ontology", "auction")
self.add_behaviour(ReceiveBidderMessagesBehaviour(), template=bidMessageTemplate)
def run_strategy(self):
"""import json
Runs the strategy for the customer agent.
"""
if not self.running_strategy:
template1 = Template()
template1.set_metadata("protocol", REQUEST_PROTOCOL)
template2 = Template()
template2.set_metadata("protocol", QUERY_PROTOCOL)
self.add_behaviour(self.strategy(), template1 | template2)
self.running_strategy = True
async def setup(self):
LogManager.log(self.name, "HighwayAgent is starting...")
high_presence_behav = self.PresenceNotificationBehav(1)
self.add_behaviour(high_presence_behav)
t1 = Template(metadata={"performative": "query"})
receiveOrderBehav = self.ReceiveOrderBehav(1)
self.add_behaviour(receiveOrderBehav, t1)
t3 = Template(metadata={"performative": "stat"})
receiveRankingBehav = self.ReceiveRankingBehav(1)
self.add_behaviour(receiveRankingBehav, t3)
simpleSwitchOrderBehav = self.SwitchOrderBehav(1)
self.add_behaviour(simpleSwitchOrderBehav)
async def setup(self):
LogManager.log(self.name, "GUIAgent is starting...")
t1 = Template(metadata={"performative": "inform"})
t2 = Template(metadata={"performative": "query"})
t3 = Template(metadata={"performative": "temp"})
gui_presence_behav = self.PresenceNotificationBehav(1)
gui_stat_behav = self.GUIStatisticsBehav(1)
gui_work_behav = self.GUIWorkingBehav(1)
gui_temp_behav = self.TemporalWorkingBehav()
self.add_behaviour(gui_presence_behav)
self.add_behaviour(gui_stat_behav, t1)
self.add_behaviour(gui_work_behav, t2)
self.add_behaviour(gui_temp_behav, t3)
async def setup(self):
# print("<RawNote> {}".format(str(self.jid).split("@")[0]))
self.set("full_note",
[self.name.split("_")[1].capitalize(), None, None])
notevalues_template = Template()
notepitch_template = Template()
notes_template = Template()
notevalues_template.set_metadata("performative", "notevalues")
notepitch_template.set_metadata("performative", "notepitch")
notes_template.set_metadata("performative", "notes")
self.add_behaviour(self.receiveNoteValue(), notevalues_template)
self.add_behaviour(self.receiveNotePitch(), notepitch_template)
self.add_behaviour(self.sendFullNote(), notes_template)
async def setup(self):
template = Template(metadata={"performative": "B1"})
self.add_behaviour(self.Behav1(period=1, start_at=datetime.now()),
template)
template = Template(metadata={"performative": "B2"})
self.add_behaviour(self.Behav2(period=5, start_at=datetime.now()),
template)
template = Template(metadata={"performative": "B3"})
self.add_behaviour(self.Behav3(period=10, start_at=datetime.now()),
template)
template = Template(metadata={"performative": "B4"})
self.add_behaviour(
self.Behav4(start_at=datetime.now() + timedelta(seconds=60)),
template)
def run_strategy(self):
"""
Sets the strategy for the transport agent.
Args:
strategy_class (``TransportStrategyBehaviour``): The class to be used. Must inherit from ``TransportStrategyBehaviour``
"""
if not self.running_strategy:
template1 = Template()
template1.set_metadata("protocol", REQUEST_PROTOCOL)
template2 = Template()
template2.set_metadata("protocol", QUERY_PROTOCOL)
self.add_behaviour(self.strategy(), template1 | template2)
self.running_strategy = True
def Launch_DataFromTroop_ListenerBehaviour(self):
class CyclicBehaviourDFT(Behaviour):
async def run(self):
msg = await self.receive(timeout=100000)
if msg:
s_content = msg.body
s_content = s_content.split()
id_agent = int(s_content[1])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.x = float(s_content[3])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.y = float(s_content[5])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.z = float(s_content[7])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.x = float(s_content[10])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.y = float(s_content[12])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.z = float(s_content[14])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.x = float(s_content[17])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.y = float(s_content[19])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.z = float(s_content[21])
self.agent.m_AgentList[id_agent].m_iHealth = int(s_content[24])
self.agent.m_AgentList[id_agent].m_iAmmo = int(s_content[26])
self.agent.CheckObjectsAtStep(id_agent)
if self.agent.CheckGameFinished(id_agent):
self.agent.InformGameFinished("ALLIED", self)
print("\n\nManager: GAME FINISHED!! Winner Team: ALLIED! (Target Returned)\n")
template = Template()
template.set_metadata("performative", "data")
self.add_behaviour(CyclicBehaviourDFT(), template)
def test_receive_with_timeout():
class RecvBehaviour(OneShotBehaviour):
async def run(self):
self.agent.recv_msg = await self.receive(5.0)
self.kill()
agent = make_connected_agent()
msg = Message(body="received body")
template = Template(body="received body")
behaviour = RecvBehaviour()
agent.add_behaviour(behaviour, template)
assert behaviour.mailbox_size() == 0
agent.start(auto_register=False)
agent._message_received(msg.prepare())
assert agent.is_alive()
assert agent.has_behaviour(behaviour)
wait_for_behaviour_is_killed(behaviour)
assert agent.recv_msg.body == "received body"
assert agent.recv_msg == msg
agent.stop()
def setUp(self):
self.agent = Mock()
self.behaviour = FastNotifyContacts()
self.behaviour.set_agent(self.agent)
self.behaviour.set_template(
Template(body='["data 1", "data 2", "data 3"]'))
self.behaviour.send = CoroutineMock()
async def setup(self):
log.info(f"[{self.name}] Server running")
self.add_behaviour(self.PresenceSetup())
self.broadcast_template = Template()
self.broadcast_template.set_metadata('action', 'send_message')
self.add_behaviour(self.BroadcastMessage(), self.broadcast_template)
def test_receive_with_timeout():
class RecvBehaviour(OneShotBehaviour):
async def run(self):
self.agent.recv_msg = await self.receive(5.0)
self.kill()
agent = MockedAgentFactory()
msg = Message(body="received body")
template = Template(body="received body")
behaviour = RecvBehaviour()
agent.add_behaviour(behaviour, template)
assert behaviour.mailbox_size() == 0
future = agent.start(auto_register=False)
future.result()
agent._message_received(msg.prepare())
assert agent.is_alive()
assert agent.has_behaviour(behaviour)
behaviour.join()
assert agent.recv_msg.body == "received body"
assert agent.recv_msg == msg
agent.stop()
async def setup(self):
template1 = Template()
template1.set_metadata(PERFORMATIVE, PERFORMATIVE_REGISTER_SERVICE)
self.add_behaviour(RegisterServiceBehaviour(), template1)
template2 = Template()
template2.set_metadata(PERFORMATIVE, PERFORMATIVE_DEREGISTER_SERVICE)
self.add_behaviour(DeregisterServiceBehaviour(), template2)
template3 = Template()
template3.set_metadata(PERFORMATIVE, PERFORMATIVE_DEREGISTER_AGENT)
self.add_behaviour(DeregisterAgentBehaviour(), template3)
template4 = Template()
template4.set_metadata(PERFORMATIVE, PERFORMATIVE_GET)
self.add_behaviour(GetServiceBehaviour(), template4)
async def setup(self):
"""Executed when the agent starts."""
logger.info("ImageAgent starting . . .")
# Ingredients names
with open((CNN_DIR / 'classes.csv'), 'r') as f:
self.CLASS_NAMES = list(csv.reader(f))[0]
# Uncomment if TensorFlow for GPU is enabled.
# gpus = tf.config.experimental.list_physical_devices('GPU')
# if gpus:
# try:
# # Currently, memory growth needs to be the same across GPUs
# for gpu in gpus:
# tf.config.experimental.set_memory_growth(gpu, True)
# logical_gpus = tf.config.experimental.list_logical_devices(
# 'GPU')
# print(len(gpus), "Physical GPUs,", len(
# logical_gpus), "Logical GPUs")
# except RuntimeError as e:
# # Memory growth must be set before GPUs have been initialized
# print(e)
b = self.ClassifyBehaviour()
t = Template()
t.set_metadata("performative", "request")
self.add_behaviour(b, t)
async def setup(self):
containers_deallocation_mt = Template()
containers_deallocation_mt.set_metadata('protocol', 'Request')
containers_deallocation_mt.set_metadata(
'action', ContainersDeallocationRequest.__key__)
self.add_behaviour(ContainersDeallocationResponder(),
containers_deallocation_mt)
def __init__(self, jid, password, *, graph, workflow, factory_creator, storage_username, verify_security=False,
neighbours=None, agent_type=None, produced_components=None, is_recovered=False):
"""
Simulation agent initializer.
:param jid: agent username in XMPP server, e.g. 'agent 0'
:param password: agent password in XMPP server, e.g. 'agent 0'
:param verify_security: XMPP server parameter - whether agents should be verified or not
:param neighbours: list of agents' username (e.g. 'agent 0') being the agent neighbours (for whom the agent can
sent a message)
"""
super().__init__(jid=jid, password=password, verify_security=verify_security)
if neighbours is None:
neighbours = dict()
self.username = jid
self.neighbours = neighbours
self.successors = self.neighbours['successors']
self.predecessors = self.neighbours['predecessors']
self.propagate_behav = None
self.listen_behav = None
self.agentType = agent_type
self.factory_creator = factory_creator
self.storage_username = storage_username
self.produced_components = produced_components
self.workflow = workflow
self.graph = graph
template = Template()
template.set_metadata("performative", "inform")
self.common_template = template
self.message_thread_counter_list = []
self.sent_messages_registry = []
self.respawn_after_breakdown = is_recovered
self.was_ever_revived = is_recovered
async def setup(self):
util.mas_print_info("[MISSILE] ({}) starting...".format(self.aid))
b = RecvBehav(self.aid)
template = Template()
template.set_metadata("performative", "inform")
self.add_behaviour(b, template)
def Launch_Sight_ResponderBehaviour(self):
class CyclicBehaviourSight(Behaviour):
async def run(self):
msg = await self.receive(timeout=100000)
if msg:
s_content = msg.body
s_content = s_content.split()
FOVObjects = self.agent.GetObjectsInFieldOfView(s_content[1])
s_content = " #: " + str(len(FOVObjects)) + " "
for s in FOVObjects:
s_content += "TEAM: " + str(s.m_eTeam) + " TYPE: " + str(s.m_eType)
s_content += " ANGLE: " + str(s.m_dAngle) + " DISTANCE: " + str(s.m_dDistance) + " "
s_content += "HEALTH: " + str(s.m_iHealth)
s_content += " ( " + str(s.m_Position.x) + " , " + str(s.m_Position.y) + " , " + str(s.m_Position.z) + " ) "
reply = msg.make_reply()
reply.body = s_content
reply.set_metadata("performative", "sight")
await self.send(reply)
template = Template()
template.set_metadata("performative", "sight")
self.add_behaviour(CyclicBehaviourSight(), template)
def test_submit_send():
agent = make_connected_agent()
class DummyBehav(OneShotBehaviour):
async def run(self):
msg_to_send = Message(to="fake@jid",
body="BODY",
metadata={"performative": "TEST"})
coro = self.send(msg_to_send)
self.agent.submit(coro)
self.kill()
template = Template(to="fake@jid")
behah = DummyBehav()
agent.add_behaviour(behah, template=template)
future = agent.start(auto_register=False)
future.result()
behah.join()
assert behah.queue.qsize() == 1
msg = behah.queue.get_nowait()
assert str(msg.to) == "fake@jid"
assert msg.body == "BODY"
assert msg.metadata == {"performative": "TEST"}
