示例#1
0
    def send_inform(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.INFORM)

        # Send message to all receivers
        self.agent.send(message)
示例#2
0
 def notify(self):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
     message.set_content(dumps(self.agent.agentInstance.table))
     message.set_system_message(is_system_message=True)
     self.STATE = 0
     super(PublisherBehaviour, self).notify(message)
示例#3
0
    def send_failure(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.FAILURE)

        # Send message to all receivers
        self.agent.send(message)
示例#4
0
    def __init__(self, aid, aa):
        super(AgenteDispositivo, self).__init__(aid=aid, debug=False)
        self.agente_alimentador = aa

        # Comportamento de Inicialização
        message = ACLMessage(ACLMessage.REQUEST)
        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_content(
            json.dumps({
                'ref': 'R_06',
                'dados': 'AUTH'
            }, indent=4))
        message.add_receiver(self.agente_alimentador.aid.localname)

        comp_request_4 = CompRequest4(self, message)

        # Comportamento que aguarda por ocorrências na rede
        comp_request_1 = CompRequest1(self)

        # Comportamento de comando de IEDs
        comp_request_3 = CompRequest3(self)

        self.behaviours.append(comp_request_4)
        self.behaviours.append(comp_request_1)
        self.behaviours.append(comp_request_3)
示例#5
0
    def send_agree(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.AGREE)

        # Send message to all receivers
        self.agent.send(message)
    def send_propose(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.PROPOSE)

        response = yield AgentSession(self, message)
        return response
 def send_message(self, receiver_agent):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content('I have received Student Object successfully')
     self.send(message)
示例#8
0
    def send_message(self, receiver_agent):
        try:
            message = ACLMessage(ACLMessage.INFORM)
            message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
            message.add_receiver(receiver_agent)
            self.add_all_agents(message.receivers)
            print("Computer's Turn")

            start = time.time()
            (m, pos_x, pos_y) = maximize()
            finish = time.time()
            print("time =", round((finish - start), 5), "sec")
            board[pos_x][pos_y] = 'O'
            print_board()
            result = finished()
            if (result == 'O'):
                print("Computer won !")
                sys.exit()
            elif (result == "Tie"):
                print("tie")
                sys.exit()

            message.set_content('Computer Agent played "O" at position')
            self.send(message)
        except:
            print("")
示例#9
0
    def send_subscribe(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.SUBSCRIBE)

        response = yield AgentSession(self, message)
        return response
示例#10
0
 def send_message(self):
     message = ACLMessage(ACLMessage.QUERY_IF)
     message.set_protocol(ACLMessage.FIPA_QUERY_PROTOCOL)
     message.add_receiver(self.receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content(self.message)
     self.send(message)
示例#11
0
 def send_response(self, response, sender):
     
     answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL)
     answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
     answer.set_content(pickle.dumps(response))
     answer.add_receiver(sender)
     self.agent.send(answer)
示例#12
0
    def send_message(self):
        try:
            message = ACLMessage(ACLMessage.INFORM)
            message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
            message.add_receiver(self.computer_agent)
            self.add_all_agents(message.receivers)
            print("Human's Turn")
            i = None
            j = None
            #check wrong inputs by human
            while (True):
                digit = True
                in_range = True
                new_pos = True
                pos = input('Enter your position:')
                if not pos.isdigit():
                    digit = False
                    print("Please enter a digit!")
                    continue

                pos = int(pos)
                if (pos < 1 or pos > 9):
                    in_range = False
                    print("Enter between 1-9")
                    continue

            # mapping the position entered with board position
                if (pos <= 3):
                    i = 0
                elif (pos > 3 and pos <= 6):
                    i = 1
                else:
                    i = 2

                if (pos % 3 == 0):
                    j = 2
                else:
                    j = pos % 3 - 1
                if (board[i][j] != '_'):
                    new_pos = False
                    print("Already occupied!")
                    continue
                break

            board[i][j] = 'X'
            print_board()
            result = finished()

            if (result == 'X'):
                print("You won !")
                sys.exit()
            elif (result == "Tie"):
                print("Tie\n")
                sys.exit()

            message.set_content('Human Agent played "X" at position' +
                                str(pos))
            self.send(message)
        except:
            print("")
示例#13
0
    def send_refuse(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.REFUSE)

        # Send message to all receivers
        self.agent.send(message)
示例#14
0
    def __init__(self, host, port, session, main_ams=True, debug=False):
        self.ams_aid = AID('ams@' + str(host) + ':' + str(port))
        super(AMS, self).__init__(self.ams_aid, debug=debug)
        self.ams = {'name': str(host), 'port': str(port)}
        super(AMS, self).update_ams(self.ams)
        self.host = host
        self.port = port
        self.session = session
        self.main_ams = main_ams

        self.agents_conn_time = dict()
        self.comport_ident = PublisherBehaviour(self)

        # message to check the connection.
        message = ACLMessage(ACLMessage.REQUEST)
        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        self.add_all(message)
        message.set_content('CONNECTION')
        message.set_system_message(is_system_message=True)

        self.comport_conn_verify = CompConnectionVerify(self, message)
        self.comport_send_conn_messages = ComportSendConnMessages(
            self, message, 4.0)
        self.comport_conn_verify_timed = ComportVerifyConnTimed(self, 10.0)
        self.comport_conn_verify_reg = CompVerifyRegister(self)

        self.system_behaviours.append(self.comport_ident)
        self.system_behaviours.append(self.comport_conn_verify)
        self.system_behaviours.append(self.comport_send_conn_messages)
        self.system_behaviours.append(self.comport_conn_verify_timed)
        self.system_behaviours.append(self.comport_conn_verify_reg)
        self.on_start()
示例#15
0
    def on_time(self):
        super(AnalisaLances, self).on_time()
        message = ACLMessage(ACLMessage.INFORM)
        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)

        # Se ja tiverem lances registrados, vemos o atual maior lance e definimos ele como novo minimo
        if self.agent.lances:
            # Verifica se existe apenas um agente concorrente
            # Caso positivo o vencedor é declarado e o programa é encerrado.
            novo_lance_minimo = max(self.agent.lances.values())
            if len(self.agent.lances) == 1:
                winner = list(self.agent.lances.keys())[0]
                self.agent.logger.log(self.agent.aid.name,
                                      f'O vencedor foi o comprador {winner}!')
                msg = ACLMessage(ACLMessage.INFORM)
                msg.add_receiver(AID(winner))
                msg.set_content('vencedor')
                self.agent.send(msg)
            else:
                self.agent.logger.log(
                    self.agent.aid.name,
                    f'Novo valor a bater {novo_lance_minimo}')

        # Caso contrario, damos o primeiro lance minimo do leilao. Que deveria vir do objeto leiloado
        else:
            novo_lance_minimo = self.agent.objeto_leiloado.valor_inicial
            self.agent.logger.log(
                self.agent.aid.name,
                'Iniciando leilão do item {} com valor inicial de R${}'.
                format(self.agent.objeto_leiloado.nome, novo_lance_minimo))

        # usa o protocolo do editor para mandar o novo lance minimo a todos os compradores
        self.agent.lances.clear()
        message.set_content(f'lance:{novo_lance_minimo}')
        self.notify(message)
示例#16
0
 def send_message(self, receiver_agent):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content(self.message)
     self.send(message)
 def __init__(self, aid):
     super(BallReceivingWinger, self).__init__(aid=aid, debug=False)
     print('Winger')
     message = ACLMessage(ACLMessage.SUBSCRIBE)
     message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
     message.set_content("Ball!!")
     self.call_later(8.0, self.launch_subscriber_protocol, message)
示例#18
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(random.random()))
     self.notify(message)
     self.inc += 0.1
示例#19
0
    def handle_request(self, message):

        # carrega o conteudo da mensagem recebida
        self.content = json.loads(message.content)

        if self.content['ref'] == 'R_04':
            display_message(self.agent.aid.name, 'Mensagem REQUEST recebida')

            # cria resposta para a mensagem recebida
            resposta = message.create_reply()
            resposta.set_performative(ACLMessage.INFORM)
            content = json.dumps({'ref': 'R_04'}, indent=4)
            resposta.set_content(content)
            self.agent.send(resposta)

            rams_desener = self.encontrar_rams_desener()

            message = ACLMessage(ACLMessage.CFP)
            message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            message.set_content(json.dumps({'ref': 'CN_01',
                                            'dados': pickle.dumps(rams_desener)
                                            },
                                indent=4))

            for agente in self.agent.topologia['alimentadores'].keys():
                if self.agent.aid.localname not in agente:
                    message.add_receiver(AID(agente))

            # lança comportamento ContractNet na versão Iniciante
            comp = CompContNet1(self.agent, message)
            self.agent.behaviours.append(comp)
            comp.on_start()
示例#20
0
    def handle_all_proposes(self, proposes):
        """
        """

        super(CompContNet1, self).handle_all_proposes(proposes)

        best_proposer = None
        higher_power = 0.0
        other_proposers = list()
        display_message(self.agent.aid.name,
                        'Analyzing ball passing possibilities...')

        i = 1

        # logic to select proposals by the higher available power.
        for message in proposes:
            content = message.content
            power = float(content)
            display_message(self.agent.aid.name,
                            'Analyzing ball passing chances {i}'.format(i=i))
            display_message(self.agent.aid.name,
                            'Chances of receiving: {pot}'.format(pot=power))
            i += 1
            if power > higher_power:
                if best_proposer is not None:
                    other_proposers.append(best_proposer)

                higher_power = power
                best_proposer = message.sender
            else:
                other_proposers.append(message.sender)

        display_message(
            self.agent.aid.name,
            'The ball passed with potential: {pot} VA'.format(
                pot=higher_power))

        if other_proposers != []:
            display_message(
                self.agent.aid.name,
                'Telling the contingent the ball will not be passed to him...')
            answer = ACLMessage(ACLMessage.REJECT_PROPOSAL)
            answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            answer.set_content('')
            for agent in other_proposers:
                answer.add_receiver(agent)

            self.agent.send(answer)

        if best_proposer is not None:
            display_message(
                self.agent.aid.name,
                'Passing the ball to {}'.format(self.agent.aid.name))

            answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL)
            answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            answer.set_content('OK')
            answer.add_receiver(best_proposer)
            self.agent.send(answer)
 def send_message(self, content):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(self.receiver_agent)
     self.add_all_agents(message.receivers)
     msg = "Played at position {}".format(content)
     message.set_content(msg)
     self.send(message)
    def send_message(self):
        message = ACLMessage(ACLMessage.INFORM)
        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_content("Your turn")
        message.add_receiver(self.opponent.aid)
        self.agentInstance.table[self.opponent.aid.localname] = self.opponent.aid

        self.call_later(1, self.send, message)
示例#23
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
 def send_message(self):
     # print('Test')
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(self.receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content('Test Message')
     self.send(message)
 def launch_subscriber_protocol(self):
     message = ACLMessage(ACLMessage.SUBSCRIBE)
     message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
     message.set_content(f'Registro: {self.aid.localname}')
     message.add_receiver(AID('leiloeiro'))
     self.protocol = SubscriberProtocol(self, message)
     self.behaviours.append(self.protocol)
     self.protocol.on_start()
示例#26
0
    def send_agree(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.AGREE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
示例#27
0
    def send_subscribe(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.SUBSCRIBE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
示例#28
0
    def send_reject_proposal(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.REJECT_PROPOSAL)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
示例#29
0
    def send_refuse(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.REFUSE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
示例#30
0
    def _build_message_for_proposer(self):
        message = ACLMessage(ACLMessage.CFP)
        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)

        message.add_receiver(self.game_agent.aid)

        message.content = pickle.dumps({'position': self.position})

        return message
示例#31
0
    def send_request(self, message: ACLMessage):
        # Only individual messages
        assert len(message.receivers) == 1

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.REQUEST)

        response = yield AgentSession(self, message)
        return response
示例#32
0
    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)

            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)
示例#33
0
    def __init__(self, aid):
        super(AgenteIniciante, self).__init__(aid=aid, debug=False)

        message = ACLMessage(ACLMessage.CFP)
        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)
示例#34
0
    def __init__(self, aid):
        super(AgenteRelogio, self).__init__(aid=aid)

        # mensagem que requisita horario do horario
        message = ACLMessage(ACLMessage.REQUEST)
        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)
示例#35
0
    def __init__(self, aid):
        super(AgenteParticipante, self).__init__(aid)

        self.protocol = SubscribeParticipant(self)
        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)
示例#36
0
    def filter(self, message):
        state = True
        
        if self.conversationID != None and self.conversationID != message.conversationID:
            state = False
        
        if self.sender != None and self.sender != message.sender:
            state = False
        
        if self.performative != None and self.performative != message.performative:
            state = False
        
        if self.protocol != None and self.protocol != message.protocol:
            state = False
            
        return state

if __name__ == '__main__':
    message = ACLMessage(ACLMessage.REQUEST)
    message.set_sender(AID('lucas'))
    message.add_receiver('allana')
    message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
    
    filtro = Filter()
    filtro.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
    
    if filtro.filter(message):
        print message.as_xml()
    else:
        print 'A mensagem foi barrada pelo protocolo'