async def on_end(self):
global senderagent
print("Negociateur finished with exit code {}.".format(
self.exit_code))
await self.agent.stop()
await senderagent.stop()
quit_spade()
def do_agents_play():
os.system('cls' if os.name == 'nt' else 'clear')
judge_jid = "j@localhost"
judge_passwd = "secret"
judge_agent = JudgeAgent(judge_jid, judge_passwd)
future = judge_agent.start(auto_register=True)
future.result()
print("Agentes jogando entre si : \n")
player1 = create_player("1", judge_jid)
player2 = create_player("2", judge_jid)
exit()
while judge_agent.is_alive():
try:
time.sleep(2)
player1.stop()
player2.stop()
judge_agent.stop()
exit()
break
except KeyboardInterrupt:
player1.stop()
player2.stop()
judge_agent.stop()
break
quit_spade()
def manager(jid, password, num_players, map_name, map_path, service_jid,
service_password, match_time, fps, port):
"""Run the manager which controls the game."""
click.echo("Running manager agent {}".format(jid))
manager_agent = Manager(players=int(num_players),
name=jid,
passwd=password,
map_name=map_name,
map_path=map_path,
service_jid=service_jid,
service_passwd=service_password,
match_time=match_time,
fps=fps,
port=port)
future = manager_agent.start()
future.result()
while manager_agent.is_alive():
try:
time.sleep(0.1)
except KeyboardInterrupt:
break
click.echo("Stopping manager . . .")
manager_agent.stop()
quit_spade()
return 0
def run():
a = ShoppingAgent(
f'{configuration.XMPP_USERNAME}@{configuration.XMPP_DOMAIN}',
configuration.XMPP_PASSWORD)
a.start()
input("Press ENTER to exit.\n")
a.stop()
spade.quit_spade()
def shutdown():
"""
turns the system off
"""
quit_spade()
logger.logger.log(logger.EVENT_SYSTEM_CLOSE)
return False
def run_around_tests():
# Code that will run before your test, for example:
# A test function will be run at this point
container = Container()
if not container.is_running:
container.__init__()
yield
# Code that will run after your test, for example:
quit_spade()
def run_around_tests():
# Code that will run before your test, for example:
# A test function will be run at this point
container = Container()
if not container.is_running:
container.__init__()
yield
# Code that will run after your test, for example:
quit_spade()
async def run(self):
self.agent.log.debug('Sending message...')
msg = tools.message_from_template(request_decision_template,
to='strategy_agent@localhost')
await self.send(msg)
self.agent.log.debug('Message sent!')
reply = await self.receive(timeout=5)
if reply:
self.agent.log.debug('Answer received!')
else:
self.agent.log.debug('Answer not received! :(')
quit_spade()
def main(name, output, oformat, max_time, autorun, config, verbose):
"""
Console script for SimFleet.
"""
if verbose > 0:
logger.remove()
logger.add(sys.stderr, level="DEBUG")
else:
logger.remove()
logger.add(sys.stderr, level="INFO")
logging.getLogger("aiohttp").setLevel(logging.WARNING)
logging.getLogger("aioopenssl").setLevel(logging.WARNING)
logging.getLogger("aiosasl").setLevel(logging.WARNING)
logging.getLogger("asyncio").setLevel(logging.WARNING)
logging.getLogger("spade").setLevel(logging.WARNING)
if verbose > 2:
logging.getLogger("spade").setLevel(logging.INFO)
if verbose > 3:
logging.getLogger("aioxmpp").setLevel(logging.INFO)
else:
logging.getLogger("aioxmpp").setLevel(logging.WARNING)
simfleet_config = SimfleetConfig(config, name, max_time, verbose)
simulator_name = "simulator_{}@{}".format(name, simfleet_config.host)
simulator = SimulatorAgent(config=simfleet_config, agentjid=simulator_name)
simulator.start()
if autorun:
simulator.run()
while not simulator.is_simulation_finished():
try:
time.sleep(0.5)
except KeyboardInterrupt:
break
simulator.stop().result()
if output:
simulator.write_file(output, oformat)
quit_spade()
sys.exit(0)
async def wait_msg(self):
print("Negociateur : Attente d'un message wait_msg")
msg = await self.receive(
timeout=20) # On attend la premiere proposition du vendeur
if msg:
if msg.body is "ko" or msg.body is "ko":
print("Negociateur ko ou ok , on restart...")
if not on_train: # Si on test le modele on arrete à la fin de la premiere vente
await self.agent.stop()
quit_spade()
else:
print("Negociateur : prix reçu: {}".format(msg.body))
prix = float(msg.body)
self.proposition_recu = prix
else:
print(
"Negociateur : Did not received any message after 20 seconds"
)
def main():
"""Main program loop."""
# Creating a pipe for bot-agent communication
parent_conn, child_conn = Pipe()
# Create and start agents
# chatAgent = ChatAgent("*****@*****.**", "123456")
chat = ChatAgent(CONFIG['CHAT_JID'], CONFIG['CHAT_PASS'], pipe=parent_conn)
cheff = CheffAgent(CONFIG['CHEFF_JID'], CONFIG['CHEFF_PASS'])
image = ImageAgent(CONFIG['IMAGE_JID'], CONFIG['IMAGE_PASS'])
f_img = image.start()
f_chf = cheff.start()
f_cht = chat.start()
f_img.result()
f_cht.result()
f_chf.result()
# Telegram Bot
bot_process = Process(target=telegramBot.start_bot,
args=(
CONFIG['telegram_token'],
child_conn,
))
bot_process.start()
time.sleep(0.5) # Assert message is displayed after logs
print("\n---\nWait until user interrupts with ctrl+C\n")
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
chat.stop()
cheff.stop()
image.stop()
logging.info("Agents finished")
quit_spade()
size = getsizeof(body)
print("{} Messages of size {} bytes received w/container: {}".format(receiver.n, size, t2 - t1))
sender.stop()
receiver.stop()
if __name__ == "__main__":
agent_credentials = {
"sender_jid": input("SenderAgent JID> "),
"sender_passwd": getpass.getpass(),
"recv_jid": input("ReceiverAgent JID> "),
"recv_passwd": getpass.getpass()
}
run_experiment(agent_credentials)
run_experiment(agent_credentials, num_msg=10000)
run_experiment(agent_credentials, body="0" * 1000)
run_experiment(agent_credentials, num_msg=10000, body="0" * 1000)
run_experiment(agent_credentials, num_msg=10000, body="0" * 100000)
run_experiment(agent_credentials, num_msg=100000, body="0" * 100000)
quit_spade()
template.set_metadata("performative", "inform")
self.add_behaviour(b, template)
async def run(self):
print("run")
#receiveragent = self.ReceiverAgent(ReceiverAgentId[0], ReceiverAgentId[1])
#await receiveragent.start(auto_register = False)
senderagent = self.SenderAgent(SenderAgentId[0], SenderAgentId[1])
await senderagent.start(auto_register=False)
msg = await self.receive(timeout=10
) # wait for a message for 10 seconds
if msg:
print("Message received with content: {}".format(msg.body))
else:
print("Did not received any message after 10 seconds")
if __name__ == "__main__":
places = PlacesAgent(PlacesAgentId[0], PlacesAgentId[1])
future = places.start()
future.result()
while places.is_alive():
try:
time.sleep(1)
except KeyboardInterrupt:
places.stop()
break
print("Agents finished")
quit_spade()
def cleanup(request):
quit_spade()
def stop_agent(agent):
agent.stop()
quit_spade()
def run(game, map_path, verbose):
"""Run a JSON game file with the players definition."""
set_verbosity(verbose)
try:
with open(game) as f:
config = json.load(f)
except json.decoder.JSONDecodeError:
click.echo(
"{} must be a valid JSON file. Run pygomas help run to see an example."
.format(game))
return -1
default = {
"host": "127.0.0.1",
"manager": "cmanager",
"service": "cservice",
"axis": [],
"allied": [],
}
for key in default.keys():
if key not in config:
config[key] = default[key]
host = config["host"]
manager_jid = "{}@{}".format(config["manager"], host)
service_jid = "{}@{}".format(config["service"], host)
troops = list()
for troop in config["axis"]:
new_troops = create_troops(troop,
host,
manager_jid,
service_jid,
map_path,
team=TEAM_AXIS)
troops += new_troops
for troop in config["allied"]:
new_troops = create_troops(troop,
host,
manager_jid,
service_jid,
map_path,
team=TEAM_ALLIED)
troops += new_troops
container = Container()
while not container.loop.is_running():
time.sleep(0.1)
futures = asyncio.run_coroutine_threadsafe(run_agents(troops),
container.loop)
futures.result()
while any([agent.is_alive() for agent in troops]):
try:
time.sleep(1)
except KeyboardInterrupt:
break
click.echo("Stopping troops . . .")
quit_spade()
return 0
