def send_prosal(self):
display_message(self.aid.localname, "sending proposal")
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.set_content(json.dumps({'price': self.price}))
message.add_receiver(AID(name="agent2@localhost:8022"))
self.send(message)
def connectionMade(self):
"""Este método é executado sempre que uma
conexão é executada entre um agente no modo
cliente e um agente no modo servidor
"""
# fase 1 de identificação do agente com o AMS
if self.fact.state == 'IDENT1':
# cria a mensagem de registro no AMS
msg = ACLMessage()
msg.add_receiver(
AID(name='AMS@' + self.fact.ams['name'] + ':' +
str(self.fact.ams['port'])))
msg.set_sender(self.fact.aid)
msg.set_performative(ACLMessage.INFORM)
msg.set_content(dumps({'ref': 'IDENT', 'aid': self.fact.aid}))
# envia a mensagem ao AMS e atualiza a flag de identificação para a
# fase 2
self.fact.state = 'IDENT2'
self.send_message(msg.get_message())
# se não é a fase de identificação 1 então o agente tenta enviar as mensagens presentes
# na fila de envio representada pela variável self.fact.messages
else:
# captura o host conectado ao agente por meio do metodo
# self.transport.getPeer()
PeerProtocol.connectionMade(self)
def connectionMade(self):
"""
Este método é executado sempre que uma conexão é executada entre
um cliente e um servidor
"""
# fase de identificação do agente com o AMS
if self.fact.state == 'IDENT':
# cria a mensagem de registro no AMS
msg = ACLMessage()
msg.add_receiver(
AID(name='AMS' + '@' + self.fact.ams['name'] + ':' +
str(self.fact.ams['port'])))
msg.set_sender(self.fact.aid)
msg.set_performative(ACLMessage.INFORM)
msg.set_content(dumps(self.fact.aid))
# envia a mensagem ao AMS
self.fact.state = 'READY'
self.sendLine(msg.get_message())
self.transport.loseConnection()
display_message(self.fact.aid.localname,
"Mensagem de autenticacao enviada")
else:
PeerProtocol.connectionMade(self)
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)
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_subscribe(self, message: ACLMessage):
message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
message.set_performative(ACLMessage.SUBSCRIBE)
response = yield AgentSession(self, message)
return response
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 connectionMade(self):
"""Este método é executado sempre que uma
conexão é executada entre um agente no modo
cliente e um agente no modo servidor
"""
# fase 1 de identificação do agente com o AMS
if self.fact.state == 'IDENT1':
# cria a mensagem de registro no AMS
msg = ACLMessage()
msg.add_receiver(
AID(
name='AMS' + '@' + self.fact.ams['name'] +
':' + str(self.fact.ams['port'])
))
msg.set_sender(self.fact.aid)
msg.set_performative(ACLMessage.INFORM)
msg.set_content(dumps(self.fact.aid))
# envia a mensagem ao AMS e atualiza a flag de identificação para a
# fase 2
self.fact.state = 'IDENT2'
self.send_message(msg.get_message())
# se não é a fase de identificação 1 então o agente tenta enviar as mensagens presentes
# na fila de envio representada pela variável self.fact.messages
else:
# captura o host conectado ao agente por meio do metodo
# self.transport.getPeer()
PeerProtocol.connectionMade(self)
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)
def connectionMade(self):
"""
Este método é executado sempre que uma conexão é executada entre
um cliente e um servidor
"""
# fase de identificação do agente com o AMS
if self.factory.state == 'IDENT':
# cria a mensagem de registro no AMS
msg = ACLMessage()
msg.add_receiver(
AID(name='AMS' + '@' + self.factory.ams['name'] + ':' + str(self.factory.ams['port'])))
msg.set_sender(self.factory.aid)
msg.set_performative(ACLMessage.INFORM)
msg.set_content(dumps(self.factory.aid))
# envia a mensagem ao AMS
self.factory.state = 'READY'
self.sendLine(msg.get_message())
self.transport.loseConnection()
else:
peer = self.transport.getPeer()
for message in self.factory.messages:
if int(message[0].port) == int(peer.port):
self.sendLine(message[1].get_message())
self.factory.messages.remove(message)
self.transport.loseConnection()
break
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)
def send_not_understood(self, message: ACLMessage):
message.set_performative(ACLMessage.NOT_UNDERSTOOD)
# Send message to all receivers
self.agent.send(message)
return AgentSession(self, message)
def send_proposal(self):
display_message(
self.aid.localname,
"Hello, we want to sell 10% of company on your investments")
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.add_receiver(self.connection)
self.send(message)
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
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
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
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
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
def inform(self, message: ACLMessage):
"""Use low-level twisted method to send message"""
message.set_performative(ACLMessage.INFORM)
receiver = message.receivers[0]
try:
self.agent.agentInstance.messages.append((receiver, message))
reactor.connectTCP(receiver.host, receiver.port,
self.agent.agentInstance)
except:
self.agent.agentInstance.messages.pop()
def send_failure(self, message: ACLMessage):
message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
message.set_performative(ACLMessage.FAILURE)
for subscriber in self._subscribers:
message.add_receiver(subscriber)
# Send message to all receivers
self.agent.send(message)
return message
def react(self, message):
super(Seller, self).react(message)
if message.performative == ACLMessage.PROPOSE:
display_message(self.aid.localname, "Which value u interested in?")
message = ACLMessage()
message.set_performative(performative=ACLMessage.ACCEPT_PROPOSAL)
message.set_content(json.dumps({'is_start_of_negotiation': False}))
message.add_receiver(self.connection)
self.send(message)
elif message.performative == ACLMessage.ACCEPT_PROPOSAL:
content = json.loads(message.content)
price = content['price']
if price == 0:
self.type = content['type']
self.type_growth[self.type] = self.calculate_growth()
price_to_sell = self.calculate_price()
message = ACLMessage(performative=ACLMessage.ACCEPT_PROPOSAL)
display_message(
self.aid.localname, "We growth on {}% last month".format(
self.type_growth[self.type]))
display_message(self.aid.localname,
"We want {}$".format(price_to_sell))
message.set_content(
json.dumps({
'is_start_of_negotiation': True,
'growth': self.type_growth[self.type],
'price': price_to_sell
}))
message.add_receiver(self.connection)
self.send(message)
else:
display_message(self.aid.localname, "Waiting for your lawyer")
display_message(self.aid.localname, "See u")
elif message.performative == ACLMessage.REJECT_PROPOSAL:
content = json.loads(message.content)
price = content['price']
min_price = self.calculate_price()
if min_price <= price:
display_message(self.aid.localname, "Agreed")
message = ACLMessage(performative=ACLMessage.ACCEPT_PROPOSAL)
message.set_content(
json.dumps({
'is_start_of_negotiation': True,
'price': price,
'growth': self.type_growth[self.type]
}))
message.add_receiver(self.connection)
self.send(message)
else:
display_message(self.aid.localname, "YCombinator always been")
message = ACLMessage(performative=ACLMessage.REJECT_PROPOSAL)
message.add_receiver(self.connection)
self.send(message)
def send_reject_proposal(self, message: ACLMessage):
session_id = message.conversation_id
receiver = message.receivers[0]
receiver_msgs = self.session_params[session_id]['receivers'][receiver]
if not receiver_msgs & {ACLMessage.ACCEPT_PROPOSAL, ACLMessage.REJECT_PROPOSAL}:
receiver_msgs.add(ACLMessage.REJECT_PROPOSAL)
message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
message.set_performative(ACLMessage.REJECT_PROPOSAL)
# Send message to all receivers
self.agent.send(message)
def react(self, message):
super(Agent2, self).react(message)
if message.performative == ACLMessage.PROPOSE:
content = json.loads(message.content)
price = int(content['price'])
display_message(self.aid.localname, "Got proposal: {}".format(price))
message = ACLMessage()
if price < self.max_price:
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.add_receiver(AID(name="agent_hello@localhost:8011"))
display_message(self.aid.localname, "Accepted")
else:
message.set_performative(ACLMessage.REJECT_PROPOSAL)
message.add_receiver(AID(name="agent_hello@localhost:8011"))
display_message(self.aid.localname, "Rejected")
self.send(message)
def react(self, message):
super(Auto, self).react(message)
if message.performative == ACLMessage.PROPOSE:
display_message(self.aid.localname, "Да, какую машину выбрали?")
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(json.dumps({'flag': False}))
message.add_receiver(AID(name="agent_client@localhost:8011"))
self.send(message)
elif message.performative == ACLMessage.ACCEPT_PROPOSAL:
content = json.loads(message.content)
price = content['price']
if price == 0:
self.type = content['type']
price = self.calculate_price()
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
display_message(self.aid.localname,
"Она стоит {}".format(price))
message.set_content(json.dumps({'flag': True, 'price': price}))
message.add_receiver(AID(name="agent_client@localhost:8011"))
self.send(message)
else:
display_message(self.aid.localname,
"Автосалон получил {}".format(price))
display_message(self.aid.localname,
"Вот ключи от вашей машины")
display_message(
self.aid.localname,
"Не забудьте пристегнуть ремни во время поездки")
display_message(self.aid.localname,
"Всего хорошего и до свидания")
elif message.performative == ACLMessage.REJECT_PROPOSAL:
content = json.loads(message.content)
price = content['price']
min_price = self.min_price()
if min_price <= price:
display_message(
self.aid.localname,
"Если вас эта стоимость не устраивает, мы можем снизить стоимость автомобиля"
)
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(json.dumps({'flag': True, 'price': price}))
message.add_receiver(AID(name="agent_client@localhost:8011"))
self.send(message)
else:
display_message(
self.aid.localname,
"Извините, но на этот автомобиль нельзя снизить цену")
message = ACLMessage()
message.set_performative(ACLMessage.REJECT_PROPOSAL)
message.add_receiver(AID(name="agent_client@localhost:8011"))
self.send(message)
def create_message(slave, params):
content = {
var.name: var.getter()
for var in slave.vars.values()
if var.causality == pade.fmi.Fmi2Causality.input
}
content.update(params)
message = ACLMessage(ACLMessage.FIPA_REQUEST_PROTOCOL)
message.set_performative(ACLMessage.REQUEST)
message.set_sender(slave.wrapper_aid)
message.add_receiver(slave.agent_aid)
message.set_message_id()
message.set_conversation_id(str(uuid1()))
message.set_content(json.dumps(content))
message.set_datetime_now()
return pickle.dumps(message)
def react(self, message):
super(Client, self).react(message)
if message.performative == ACLMessage.PROPOSE:
display_message(self.aid.localname, "Добрый день!")
display_message(self.aid.localname, "Я хочу купить машину")
display_message(self.aid.localname, "Что можете предложить?")
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.add_receiver(AID(name="agent_auto@localhost:8022"))
self.send(message)
elif message.performative == ACLMessage.ACCEPT_PROPOSAL:
content = json.loads(message.content)
flag = content['flag']
if not flag:
random_number = int(random.randint(0, 3))
random_type = self.model_auto[random_number]
display_message(
self.aid.localname,
"Я хочу приобрести {} машину".format(random_type))
display_message(self.aid.localname,
"Я располагаю суммой {}".format(self.price))
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(
json.dumps({
'type': random_type,
'price': 0
}))
message.add_receiver(AID(name="agent_auto@localhost:8022"))
self.send(message)
else:
price = content['price']
if self.price >= price:
display_message(self.aid.localname,
"Этот вариант мне походит ")
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(json.dumps({'price': price}))
message.add_receiver(AID(name="agent_auto@localhost:8022"))
self.send(message)
else:
display_message(self.aid.localname, "У меня столько нет")
display_message(self.aid.localname,
"Сейчас у меня{}".format(self.price))
message = ACLMessage()
message.set_performative(ACLMessage.REJECT_PROPOSAL)
message.set_content(json.dumps({'price': self.price}))
message.add_receiver(AID(name="agent_auto@localhost:8022"))
self.send(message)
elif message.performative == ACLMessage.REJECT_PROPOSAL:
display_message(self.aid.localname, "Спасибо, до свидания")
def connectionMade(self):
"""
Este método é executado sempre que uma conexão é executada entre
um cliente e um servidor
"""
# fase de identificação do agente com o AMS
if self.fact.state == 'IDENT':
# cria a mensagem de registro no AMS
msg = ACLMessage()
msg.add_receiver(
AID(name='AMS' + '@' + self.fact.ams['name'] + ':' + str(self.fact.ams['port'])))
msg.set_sender(self.fact.aid)
msg.set_performative(ACLMessage.INFORM)
msg.set_content(dumps(self.fact.aid))
# envia a mensagem ao AMS
self.fact.state = 'READY'
self.sendLine(msg.get_message())
self.transport.loseConnection()
display_message(self.fact.aid.localname, "Mensagem de autenticacao enviada")
else:
PeerProtocol.connectionMade(self)
def react(self, message):
super(Buyer, self).react(message)
if message.performative == ACLMessage.PROPOSE:
display_message(self.aid.localname, "Hello!")
display_message(self.aid.localname,
"How much you growth last month?")
message = ACLMessage(performative=ACLMessage.PROPOSE)
message.add_receiver(self.connection)
self.send(message)
elif message.performative == ACLMessage.ACCEPT_PROPOSAL:
content = json.loads(message.content)
is_start_of_negotiation = content['is_start_of_negotiation']
if not is_start_of_negotiation:
random_number = int(random.randint(0, 2))
random_type = self.metrics[random_number]
display_message(self.aid.localname,
"Let's talk about {}".format(random_type))
display_message(self.aid.localname,
"We can invest {}$".format(self.hedge))
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(
json.dumps({
'type': random_type,
'price': 0
}))
message.add_receiver(AID(name="startup@localhost:8022"))
self.send(message)
else:
growth = content['growth']
price = content['price']
if self.hedge >= price or (
growth and (price / self.hedge < growth / 100)):
display_message(self.aid.localname,
"We invest, take money")
message = ACLMessage()
message.set_performative(ACLMessage.ACCEPT_PROPOSAL)
message.set_content(json.dumps({'price': price}))
message.add_receiver(AID(name="startup@localhost:8022"))
self.send(message)
else:
display_message(self.aid.localname,
"To expensive for such valuation")
display_message(
self.aid.localname, "We can suggest only {}$".format(
(self.hedge * growth) / 100))
message = ACLMessage()
message.set_performative(ACLMessage.REJECT_PROPOSAL)
message.set_content(json.dumps({'price': self.hedge}))
message.add_receiver(AID(name="startup@localhost:8022"))
self.send(message)
elif message.performative == ACLMessage.REJECT_PROPOSAL:
display_message(self.aid.localname, "Thanks, see u")
def send_proposal(self):
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.add_receiver(AID(name="client@localhost:8011"))
self.send(message)
def send_proposal(self):
display_message(self.aid.localname, "Здравствуйте, вам чем-то помочь?")
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.add_receiver(AID(name="agent_client@localhost:8011"))
self.send(message)
def post(self, performative, content):
message = ACLMessage()
message.add_receiver(AID(name="employer@localhost:8022"))
message.set_content(json.dumps(content))
message.set_performative(performative)
self.send(message)
