P A DE. Pade Documentation. Release 1.0

Transcription

1 P A DE Pade Documentation Release 1.0 May 31, 2016

2

3 Contents 1 Multi-Agent Systems in Python! PADE is Simple! PADE is easy to install! General Functionalities User Guide Installation Hello, world! My first agent Time agents Sending messages Receiving messages Using call_later() method Sending objects Filtering Messages GUI Protocols PADE API References API PADE i

4 ii

5 CHAPTER 1 Multi-Agent Systems in Python! PADE is a framework for the development, execution, and management of multi-agent systems in distributed computer environments. PADE is fully written in Python code and uses the libraries from Twisted project to allow communication amonge the network nodes. PADE is freeware, licensed under the MIT license terms, developed by the Smart Power Grids Research Group (GREI) with the Department of Electrical Engineering of the Federal University of Ceará. Anyone who is interested to contribute to the project is invited to download, run, test, and provide the developers with feedback about the platform. 1.1 PADE is Simple! # This is file start_mas.py from pade.misc.common import set_ams, start_loop if name == main : set_ams( localhost, 8000) start_loop(list(), gui=true) 1.2 PADE is easy to install! To install PADE, just type the following command line from the prompt in a Linux terminal: 1

6 $ pip install pade $ python start_ams.py 1.3 General Functionalities PADE was developed according to requirements for automation systems. It offers the following library resources for the development of multi-agent systems: Object Orientation abstraction for the implementation of a proper environment that allows agents to be executed using object-oriented concepts; Execution Environment module for the initialization of the agent execution environment, which is entirely developed in Python code; FIPA-ACL standard messages module for the implementation and handling of FIPA- ACL messages; Message Filter module that allows filtering messages as desired; FIPA Protocols module for the proper implementation of protocols as defined by FIPA; Cyclic and Temporal Behaviors module for the implementation of cyclical and temporal behavior; Database module for the interaction with database; Sending Serialized Objects it is possible to send serialized objects as a content of FIPA- ACL messages. In addition to the aforementioned functionalities, PADE is easy to install and setup, being multi-platform so that it can be installed and used in embedded hardware running distinct operating systems such as Linux, Raspberry Pi, BeagleBone Black, as well as Windows. 2 Chapter 1. Multi-Agent Systems in Python!

7 CHAPTER 2 User Guide 2.1 Installation Installing PADE in your PC, laptop, or embedded device is quite easy. You just need to be connected to the internet! Installation via pip To install PADE via pip, just type the following command line: $ pip install pade Done! PADE is installed! Warning: Warning: PADE has been officially tested in Ubuntu LTS environment, as it is necessary to install packages python-twisted-qt4reactor and pyside for this purpose Installation via GitHub If you wish to access PADE source code and install it using this approach, just type the following command lines: $ git clone $ cd Pade $ python setup.py install Done! PADE is ready to be used! Test Python interpreted using the following command: 3

8 from pade.misc.utility import display_message Installing PADE in a virtual environment When dealing with Python modules, it is important to know how to create and manipulate virtual environments in order to manage the project dependencies in a more organized way. Here we will show how it is possible to create a virtual Python environment, activating it and using pip to install PADE. Please, access Python Guide for a more detailed view on virtual Python environments: Firstly you need to install virtualenv package in your PC typing the following command: $ pip install virtualenv After installing virtualenv, it is time to create a virtual environment with the following command: $ cd my_project_folder $ virtualenv venv Type the following command to activate the virtual environment: $ source venv/bin/activate Now, just install PADE via pip: $ pip install pade Activating the graphical user interface (GUI) It is necessary to install PySide package, which is a Qt binding, so that PADE graphical user interface (GUI can be properly used. Since there are no Pyside binaries available for Linux and the involved procedure is quite long, it is necessary to perform the following actions: 1. Install PySide with the following command: $ sudo apt-get install python-pyside 2. Copy PySide installation folder from folder site-packages, which is the standard path used by your operating system, to the one where the standard packages of the virtual environment are currently installed. In this case, the path is venv/lib/python2.7/site-packages. Done! PySide is installed in the virtual environment, but another procedure must still be carried out, which consists in installing the reactor that interacts with Pyside event loop. For this purpose, type the following command: 4 Chapter 2. User Guide

9 $ sudo apt-get install python-qt4reactor 2.2 Hello, world! PADE was created with a main purpose: simplicity! After PADE is installed in your PC, it is quite simple to start using it. In a given folder, create a file called start_mas.py by using your favorite text editor. Then type (or copy and paste) the following code inside it: # this is file start_mas.py from pade.misc.common import set_ams, start_loop if name == main : set_ams( localhost, 8000) start_loop(list(), gui=true) You will see a graphic interface like this: 2.2. Hello, world! 5

10 2.3 My first agent Now it is time to create a real agent! Creating my first agent In order to create your first agent, open your favorite text editor and type (or copy and paste) the following code: from pade.misc.utility import display_message from pade.misc.common import set_ams, start_loop from pade.core.agent import Agent from pade.acl.aid import AID class AgenteHelloWorld(Agent): def init (self, aid): super(agentehelloworld, self). init (aid=aid, debug=false) display_message(self.aid.localname, Hello World! ) if name == main : set_ams( localhost, 8000, debug=false) agents = list() agente_hello = AgenteHelloWorld(AID(name= agente_hello )) agente_hello.ams = { name : localhost, port : 8000} agents.append(agente_hello) start_loop(agents, gui=true) This is an agent, but it is not quite useful at all, is it? It can be only run once. :( The following question remains: how is it possible to create an agent whose behavior is run from time to time? 2.4 Time agents In real applications the agent behavior is typically run from time to time, and not only once. How is it possible to implement it in PADE? :( 6 Chapter 2. User Guide

11 2.4.1 Running a time agent This is the example of an agent that runs indefinitely at 1.0-second intervals. #!coding=utf-8 # Hello world temporal in PADE! # # Criado por Lucas S Melo em 21 de julho de Fortaleza, Ceará - Brasil from pade.behaviours.protocols import TimedBehaviour from pade.misc.utility import display_message from pade.misc.common import set_ams, start_loop from pade.core.agent import Agent from pade.acl.aid import AID class ComportTemporal(TimedBehaviour): def init (self, agent, time): super(comporttemporal, self). init (agent, time) def on_time(self): super(comporttemporal, self).on_time() display_message(self.agent.aid.localname, Hello World! ) class AgenteHelloWorld(Agent): def init (self, aid): super(agentehelloworld, self). init (aid=aid, debug=false) comp_temp = ComportTemporal(self, 1.0) self.behaviours.append(comp_temp) if name == main : set_ams( localhost, 8000, debug=false) agents = list() agente_1 = AgenteHelloWorld(AID(name= agente_1 )) agente_1.ams = { name : localhost, port : 8000} agents.append(agente_1) start_loop(agents, gui=true) 2.4. Time agents 7

12 2.4.2 Running two time agents What if two agents with the same behavior are necessary? No problem at all. Just instantiate another agent with the same class. if name == main : set_ams( localhost, 8000, debug=false) agents = list() agente_1 = AgenteHelloWorld(AID(name= agente_1 )) agente_1.ams = { name : localhost, port : 8000} agente_2 = AgenteHelloWorld(AID(name= agente_2 )) agente_2.ams = { name : localhost, port : 8000} agents.append(agente_1) agents.append(agente_2) start_loop(agents, gui=true) 2.5 Sending messages Sending a message using PADE is quite simple! The messages sent by PADE-based agents use FIPA-ACL standard and have the following fields: conversation-id: conversation unique identity; performative: message label; sender: message sender; receivers: message receivers; content: message content; protocol: message protocol; language: adopted language; encoding: encoding message; ontology: adopted ontology; reply-with: expression used by the answer agent to identify a message; reply-by: reference to a previous action, where the message is an answer. in-reply-to: date/time label indicating when an answer must be received. 8 Chapter 2. User Guide

13 2.5.1 FIPA-ACL messages in PADE A FIPA-ACL message can be structured in the following form: from pade.acl.messages import ACLMessage, AID message = ACLMessage(ACLMessage.INFORM) message.set_protocol(aclmessage.fipa_request_protocol) message.add_receiver(aid( agent_receiver )) message.set_content( Hello, Agent! ) Sending a Message in PADE Once inside a given instance of class Agent(), the message can be sent by simply typing the following command: self.send(message) FIPA-ACL standard messages By using print message command, a FIPA-ACL message will be displayed as follows: (inform :conversationid b2e806b8-50a0-11e5-b3b6-e8b1fc5c3cdf :receiver (set (agent-identifier :name agent_destination@localhost:51645 :addresses (sequence localhost:51645 ) ) ) ) :content "Hello, agent!" :protocol fipa-request protocol XML standard messages It is also possible to get messages in XML format using print message.as_xml() command Sending messages 9

14 <?xml version="1.0"?> <ACLMessage date="01/09/2015 as 08:58:03:113891"> <performative>inform</performative> <sender/> <receivers> </receivers> <reply-to/> <content>ola Agente</content> <language/> <enconding/> <ontology/> <protocol>fipa-request protocol</protocol> <conversationid>b2e806b8-50a0-11e5-b3b6-e8b1fc5c3cdf</conversationid> <reply-with/> <in-reply-to/> <reply-by/> </ACLMessage> 2.6 Receiving messages In order to allow agents to receive messages in PADE, it is simply necessary to implement react() method inside the class that inherits information from class Agent() Receiving FIPA-ACL messages in PADE The following example shows the implementation of two distinct agents: sender, which is modeled by class Sender(), being responsible for sending a message; and receiver, which is modeled by class Receiver(), which receives the sent message and also aggregates react() method. from pade.misc.utility import display_message from pade.misc.common import set_ams, start_loop from pade.core.agent import Agent from pade.acl.aid import AID from pade.acl.messages import ACLMessage class Remetente(Agent): def init (self, aid): super(remetente, self). init (aid=aid, debug=false) def on_start(self): 10 Chapter 2. User Guide

15 display_message(self.aid.localname, Enviando Mensagem ) message = ACLMessage(ACLMessage.INFORM) message.add_receiver(aid( destinatario )) message.set_content( Ola ) self.send(message) def react(self, message): pass class Destinatario(Agent): def init (self, aid): super(destinatario, self). init (aid=aid, debug=false) def react(self, message): display_message(self.aid.localname, Mensagem recebida ) if name == main : set_ams( localhost, 8000, debug=false) agentes = list() destinatario = Destinatario(AID(name= destinatario )) destinatario.ams = { name : localhost, port : 8000} agentes.append(destinatario) remetente = Remetente(AID(name= remetente )) remetente.ams = { name : localhost, port : 8000} agentes.append(remetente) start_loop(agentes, gui=true) GUI It is possible to see PADE GUI as follows, which shows the agents registered in the multiagent system. By clicking the message received by the agent, it is possible to see its respective content. One moment, please! PADE allows postponing the execution of a given code part quite simply! Just employ call_later() method, which is available in class Agent() Receiving messages 11

16 12 Chapter 2. User Guide

17 2.7 Using call_later() method In order to use call_later() properly, the following parameters must be specified: delay type, method supposed to be called after such time interval and its respective argument using the following syntax: call_later(time, method, *args). The following code employs call_later() in classe Sender() using on_start() method to ensure that all agents are launched in the platform, thus initializing send_message() 4.0 seconds after the execution of agents: from pade.misc.utility import display_message from pade.misc.common import set_ams, start_loop from pade.core.agent import Agent from pade.acl.aid import AID from pade.acl.messages import ACLMessage class Remetente(Agent): def init (self, aid): super(remetente, self). init (aid=aid, debug=false) def on_start(self): self.call_later(4.0, self.send_message) def send_message(self): display_message(self.aid.localname, Enviando Mensagem ) message = ACLMessage(ACLMessage.INFORM) message.add_receiver(aid( destinatario )) message.set_content( Ola ) self.send(message) def react(self, message): pass class Destinatario(Agent): def init (self, aid): super(destinatario, self). init (aid=aid, debug=false) def react(self, message): display_message(self.aid.localname, Mensagem recebida ) if name == main : set_ams( localhost, 8000, debug=false) 2.7. Using call_later() method 13

18 agentes = list() destinatario = Destinatario(AID(name= destinatario )) destinatario.ams = { name : localhost, port : 8000} agentes.append(destinatario) remetente = Remetente(AID(name= remetente )) remetente.ams = { name : localhost, port : 8000} agentes.append(remetente) start_loop(agentes, gui=true) 2.8 Sending objects It is not always possible to represent the content that must be sent to other agents using a simple text, is it? In order to attach objects to FIPA-ACL messages in PADE, it is only necessary to use the Python native module called pickle Sending serialized objects using pickle The following steps can be used to send a serialized object with pickle: import pickle Pickle is a library dedicated to serialized objects, while pickle.dumps() must be used according to the following syntax: dados = { nome : agente_consumidor, porta : 2004} dados_serial = pickle.dumps(dados) message.set_content(dados_serial) Done! The object can now be sent as attached to the message content Receiving serialized objects using pickle Now, the object can be received by loading it with the following command: dados_serial = message.content dados = pickle.loads(dados_serial) Plain simple ;) 14 Chapter 2. User Guide

19 2.9 Filtering Messages It is possible to implement message filters in PADE in a simple and direct way using class Filter(): from pade.acl.filters import Filter Filtering messages with Filters module Let s consider the following message: from pade.acl.messages import ACLMessage from pade.acl.aid import AID message = ACLMessage(ACLMessage.INFORM) message.set_protocol(aclmessage.fipa_request_protocol) message.set_sender(aid( remetente )) message.add_receiver(aid( destinatario )) In this case, it is possible to create the following filter: from pade.acl.filters import Filter f.performative = ACLMessage.REQUEST It is possible to notice how the filter works when applied to a message in a Python interpreter session. >> f.filter(message) False Now, the filter is adjusted for another condition: f.performative = ACLMessage.INFORM Once again, it is applied to the message, as a new result is obtained. >> f.filter(message) True 2.10 GUI Activating the GUI in PADE is rather simple, as it is only necessary to set parameter gui=true in the following function: 2.9. Filtering Messages 15

20 start_loop(agentes, gui=true) PADE GUI is currently simple and does not present many functions, since its implementation is based on framework Qt/PySide, thus bringing some complex issues to be solved. However, version 2.0 is supposed to present a more complete and functional web-based GUI using Flask framework Protocols PADE supports the most used protocols established by FIPA, which are: FIPA-Request FIPA-Contract-Net FIPA-Subscribe Any protocol in PADE must be implemented as an extended class. For instance, if FIPA- Request protocol is required, a given class supposed to inherit features from class FipaRequestProtocol is necessary. from pade.behaviours.protocols import FipaRequestProtocol class ProtocoloDeRequisicao(FipaRequestProtocol): def init (self): super(protocoloderequisicao, self). init () FIPA-Request FIPA-Request is the simplest protocol used as a normalized representation for requesting a task or information from an initiator agent to a participant one. The communication diagram used by FIPA-Request protocol is shown as follows. 16 Chapter 2. User Guide

21 In order to show an example using FIPA-Request, the interaction between two agents is considered. Agent Clock displays the updated time and date every one second, although it is not able to determine such data. On the other hand, agent Time is used to provide them accurately. Then, FIPA-Request can be used so that information is changed between the agents. Agent Clock acts as an initiator, while agent Time corresponds to the participant according to the following code: from pade.misc.common import start_loop, set_ams from pade.misc.utility import display_message from pade.core.agent import Agent from pade.acl.messages import ACLMessage from pade.acl.aid import AID from pade.behaviours.protocols import FipaRequestProtocol from pade.behaviours.protocols import TimedBehaviour from datetime import datetime class CompRequest(FipaRequestProtocol): """Comportamento FIPA Request do agente Horario""" def init (self, agent): super(comprequest, self). init (agent=agent, message=none, is_initiator=false) def handle_request(self, message): super(comprequest, self).handle_request(message) display_message(self.agent.aid.localname, mensagem request recebida ) now = datetime.now() Protocols 17

22 reply = message.create_reply() reply.set_performative(aclmessage.inform) reply.set_content(now.strftime( %d/%m/%y - %H:%M:%S )) self.agent.send(reply) class CompRequest2(FipaRequestProtocol): """Comportamento FIPA Request do agente Relogio""" def init (self, agent, message): super(comprequest2, self). init (agent=agent, message=message, is_initiator=true) def handle_inform(self, message): display_message(self.agent.aid.localname, message.content) class ComportTemporal(TimedBehaviour): """Comportamento FIPA Request do agente Relogio""" def init (self, agent, time, message): super(comporttemporal, self). init (agent, time) self.message = message def on_time(self): super(comporttemporal, self).on_time() self.agent.send(self.message) class AgenteHorario(Agent): """Classe que define o agente Horario""" def init (self, aid): super(agentehorario, self). init (aid=aid, debug=false) self.comport_request = CompRequest(self) self.behaviours.append(self.comport_request) class AgenteRelogio(Agent): """Classe que define o agente Relogio""" def init (self, aid): super(agenterelogio, self). init (aid=aid) # mensagem que requisita horario do horario message = ACLMessage(ACLMessage.REQUEST) 18 Chapter 2. User Guide

23 message.set_protocol(aclmessage.fipa_request_protocol) message.add_receiver(aid(name= horario )) message.set_content( time ) self.comport_request = CompRequest2(self, message) self.comport_temp = ComportTemporal(self, 1.0, message) self.behaviours.append(self.comport_request) self.behaviours.append(self.comport_temp) def main(): agentes = list() set_ams( localhost, 8000, debug=false) a = AgenteHorario(AID(name= horario )) a.ams = { name : localhost, port : 8000} agentes.append(a) a = AgenteRelogio(AID(name= relogio )) a.ams = { name : localhost, port : 8000} agentes.append(a) start_loop(agentes, gui=true) if name == main : main() All modules and classes necessary for the implementation of agents are imported in the first part of the code. Then the classes responsible for the protocol implementation can be defined i.e. classes BehRequest and BehRequest2, which are associated with the behaviors of agents Time and Clock, respectively. Since agent Clock needs to send a request to agent Time every one second, a timed behavior must be associated to it, which is defined according to class TimedBehavior. Then the very agents are defined in classes AgentTime and AgentClock, which are an extension of class Agent and determine their respective behaviors and protocols. Function main is defined in the last part of the code, which indicates the location of agent mas, thus instantiating all agents and starting the loop execution FIPA-Contract-Net FIPA-Contract-Net protocol is used in cases where any negotiation between agents is necessary. Analogously to FIPA-Request protocol, there are two types of agents: one responsible for starting the negotiation and making requests, called initiator; and one or more Protocols 19

24 agents that join the negotiation, called participants, which answer the requests sent by the initiator. Let s see an example. An example regarding the use of FIPA-ContractNet in negotiation is shown as follows, where an initiator agent requests electric power to another two participant agents. from pade.misc.common import start_loop, set_ams from pade.misc.utility import display_message from pade.core.agent import Agent from pade.acl.messages import ACLMessage from pade.acl.aid import AID from pade.behaviours.protocols import FipaContractNetProtocol class CompContNet1(FipaContractNetProtocol): CompContNet1 Comportamento FIPA-ContractNet Iniciante que envia mensagens CFP para outros agentes alimentadores solicitando propostas de restauração. Este comportamento também faz a analise das das propostas e analisa-as selecionando a que julga ser a melhor def init (self, agent, message): 20 Chapter 2. User Guide

25 super(compcontnet1, self). init ( agent=agent, message=message, is_initiator=true) self.cfp = message def handle_all_proposes(self, proposes): """ """ super(compcontnet1, self).handle_all_proposes(proposes) melhor_propositor = None maior_potencia = 0.0 demais_propositores = list() display_message(self.agent.aid.name, Analisando propostas... ) i = 1 # lógica de seleção de propostas pela maior potência disponibilizada for message in proposes: content = message.content potencia = float(content) display_message(self.agent.aid.name, Analisando proposta {i}.format(i=i)) display_message(self.agent.aid.name, Potencia Ofertada: {pot}.format(pot=potencia)) i += 1 if potencia > maior_potencia: if melhor_propositor is not None: demais_propositores.append(melhor_propositor) maior_potencia = potencia melhor_propositor = message.sender else: demais_propositores.append(message.sender) display_message(self.agent.aid.name, A melhor proposta foi de: {pot} VA.format( pot=maior_potencia)) if demais_propositores!= []: display_message(self.agent.aid.name, Enviando respostas de recusa... ) resposta = ACLMessage(ACLMessage.REJECT_PROPOSAL) resposta.set_protocol(aclmessage.fipa_contract_net_protocol) resposta.set_content( ) for agente in demais_propositores: resposta.add_receiver(agente) Protocols 21

26 self.agent.send(resposta) if melhor_propositor is not None: display_message(self.agent.aid.name, Enviando resposta de aceitacao... ) resposta = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) resposta.set_protocol(aclmessage.fipa_contract_net_protocol) resposta.set_content( OK ) resposta.add_receiver(melhor_propositor) self.agent.send(resposta) def handle_inform(self, message): """ """ super(compcontnet1, self).handle_inform(message) display_message(self.agent.aid.name, Mensagem INFORM recebida ) def handle_refuse(self, message): """ """ super(compcontnet1, self).handle_refuse(message) display_message(self.agent.aid.name, Mensagem REFUSE recebida ) def handle_propose(self, message): """ """ super(compcontnet1, self).handle_propose(message) display_message(self.agent.aid.name, Mensagem PROPOSE recebida ) class CompContNet2(FipaContractNetProtocol): CompContNet2 Comportamento FIPA-ContractNet Participante que é acionado quando um agente recebe uma mensagem do Tipo CFP enviando logo em seguida uma proposta e caso esta seja selecinada realiza as as análises de restrição para que seja possível a restauração def init (self, agent): super(compcontnet2, self). init (agent=agent, message=none, is_initiator=false) 22 Chapter 2. User Guide

27 def handle_cfp(self, message): """ """ self.agent.call_later(1.0, self._handle_cfp, message) def _handle_cfp(self, message): """ """ super(compcontnet2, self).handle_cfp(message) self.message = message display_message(self.agent.aid.name, Mensagem CFP recebida ) resposta = self.message.create_reply() resposta.set_performative(aclmessage.propose) resposta.set_content(str(self.agent.pot_disp)) self.agent.send(resposta) def handle_reject_propose(self, message): """ """ super(compcontnet2, self).handle_reject_propose(message) display_message(self.agent.aid.name, Mensagem REJECT_PROPOSAL recebida ) def handle_accept_propose(self, message): """ """ super(compcontnet2, self).handle_accept_propose(message) display_message(self.agent.aid.name, Mensagem ACCEPT_PROPOSE recebida ) resposta = message.create_reply() resposta.set_performative(aclmessage.inform) resposta.set_content( OK ) self.agent.send(resposta) class AgenteIniciante(Agent): def init (self, aid): super(agenteiniciante, self). init (aid=aid, debug=false) message = ACLMessage(ACLMessage.CFP) Protocols 23

28 message.set_protocol(aclmessage.fipa_contract_net_protocol) message.set_content( 60.0 ) message.add_receiver(aid( AP1 )) message.add_receiver(aid( AP2 )) comp = CompContNet1(self, message) self.behaviours.append(comp) self.call_later(2.0, comp.on_start) class AgenteParticipante(Agent): def init (self, aid, pot_disp): super(agenteparticipante, self). init (aid=aid, debug=false) self.pot_disp = pot_disp comp = CompContNet2(self) self.behaviours.append(comp) if name == " main ": set_ams( localhost, 5000, debug=false) aa_1 = AgenteIniciante(AID(name= AI1 )) aa_1.ams = { name : localhost, port : 5000} aa_2 = AgenteParticipante(AID(name= AP1 ), 150.0) aa_2.ams = { name : localhost, port : 5000} aa_3 = AgenteParticipante(AID(name= AP2 ), 100.0) aa_3.ams = { name : localhost, port : 5000} agents_list = list([aa_1, aa_2, aa_3]) start_loop(agents_list, gui=true) The code that implements the communication between agents using FIPA-ContractNet defines two classes for the protocol. The first one corresponds to the initiator behavior (CompContNet1), while the second one represents the participant behavior (CompCont- Net2). It is worth to mention that a CFP (call for proposals) message is necessary in order to structure the initiator class and call on_start() method. This action occurs inside the class responsible for implementing the initiator agent i.e. AgentInitiator(). On the other hand, AgentParticipant() is responsible for the implementation of agents that present proposals for the negotiation. 24 Chapter 2. User Guide

29 The messages regarding the negotiation can be seen in PADE GUI as follows FIPA-Subscribe FIPA-Subscribe protocol implements the editor-subscriber behavior, which employs an agent editor that can accept the association of other agents eventually interested in some specific information. The subscriber agent then receives a message whenever information is available from the editor. Let s see an example: In order to subscribe to information, a SUBSCRIBE message must be sent from the agent to the editor. Subscription can be then be accepted or denied (AGREE/REFUSE). If information is updated, the editor is responsible for publishing it to all respective subscribers by sending INFORM messages. The code for the implementation of one agent editor and two agents subscribers using PADE can be seen as follows. from pade.misc.common import start_loop, set_ams from pade.misc.utility import display_message from pade.core.agent import Agent from pade.acl.aid import AID from pade.acl.messages import ACLMessage Protocols 25

30 from pade.behaviours.protocols import FipaSubscribeProtocol, TimedBehaviour from numpy import sin class SubscribeInitiator(FipaSubscribeProtocol): def init (self, agent, message): super(subscribeinitiator, self). init (agent, message, is_initiator=true) def handle_agree(self, message): display_message(self.agent.aid.name, message.content) def handle_inform(self, message): display_message(self.agent.aid.name, message.content) class SubscribeParticipant(FipaSubscribeProtocol): def init (self, agent): super(subscribeparticipant, self). init (agent, message=none, is_initiator=false) def handle_subscribe(self, message): 26 Chapter 2. User Guide

31 self.register(message.sender) display_message(self.agent.aid.name, message.content) resposta = message.create_reply() resposta.set_performative(aclmessage.agree) resposta.set_content( Pedido de subscricao aceito ) self.agent.send(resposta) def handle_cancel(self, message): self.deregister(self, message.sender) display_message(self.agent.aid.name, message.content) def notify(self, message): super(subscribeparticipant, self).notify(message) class Time(TimedBehaviour): def init (self, agent, notify): super(time, self). init (agent, 1) self.notify = notify self.inc = 0 def on_time(self): super(time, self).on_time() message = ACLMessage(ACLMessage.INFORM) message.set_protocol(aclmessage.fipa_subscribe_protocol) message.set_content(str(sin(self.inc))) self.notify(message) self.inc += 0.1 class AgenteInitiator(Agent): def init (self, aid, message): super(agenteinitiator, self). init (aid) self.protocol = SubscribeInitiator(self, message) self.behaviours.append(self.protocol) class AgenteParticipante(Agent): def init (self, aid): super(agenteparticipante, self). init (aid) self.protocol = SubscribeParticipant(self) Protocols 27

32 self.timed = Time(self, self.protocol.notify) self.behaviours.append(self.protocol) self.behaviours.append(self.timed) if name == main : set_ams( localhost, 5000, debug=false) editor = AgenteParticipante(AID( editor )) editor.ams = { name : localhost, port : 5000} msg = ACLMessage(ACLMessage.SUBSCRIBE) msg.set_protocol(aclmessage.fipa_subscribe_protocol) msg.set_content( Pedido de subscricao ) msg.add_receiver( editor ) ass1 = AgenteInitiator(AID( assinante_1 ), msg) ass1.ams = { name : localhost, port : 5000} ass2 = AgenteInitiator(AID( assinante_2 ), msg) ass2.ams = { name : localhost, port : 5000} agentes = [editor, ass1, ass2] start_loop(agentes, gui=true) 28 Chapter 2. User Guide

33 CHAPTER 3 PADE API References 3.1 API PADE Aqui estão todos os módulos que são de interesse para utilização do PADE, tais como o módulo que contém a classe Agent, módulo de construção de mensagens e de construção de comportamentos. 29