def _broadcast(agent, term, intention):
# Illocutionary force.
ilf = agentspeak.grounded(term.args[0], intention.scope)
if not agentspeak.is_atom(ilf):
return
if ilf.functor == "tell":
goal_type = agentspeak.GoalType.belief
trigger = agentspeak.Trigger.addition
elif ilf.functor == "untell":
goal_type = agentspeak.GoalType.belief
trigger = agentspeak.Trigger.removal
elif ilf.functor == "achieve":
goal_type = agentspeak.GoalType.achievement
trigger = agentspeak.Trigger.addition
else:
raise agentspeak.AslError("unknown illocutionary force: %s" % ilf)
# Prepare message.
message = agentspeak.freeze(term.args[1], intention.scope, {})
tagged_message = message.with_annotation(
agentspeak.Literal("source", (agentspeak.Literal(agent.name), )))
# Broadcast.
for receiver in agent.env.agents.values():
if receiver == agent:
continue
receiver.call(trigger, goal_type, tagged_message,
agentspeak.runtime.Intention())
yield
def handle_sim_start(self, simulation):
self._set_belief("id", simulation.get("id"))
self._set_belief("map", simulation.get("map"))
self._set_belief("seedCapital", int(simulation.get("seedCapital")))
self._set_belief("steps", int(simulation.get("steps")))
self._set_belief("team", simulation.get("team"))
role = simulation.find("role")
self._set_belief(
"role", agentspeak.Literal(role.get("name").lower()),
int(role.get("speed")), int(role.get("load")),
int(role.get("battery")),
tuple(tool.get("name") for tool in role.findall("./tool")))
# Update item beliefs.
item_beliefs = []
for item in simulation.findall("./item"):
tools = tuple(tool.get("name") for tool in item.findall("./tool"))
parts = tuple(
agentspeak.Literal("parts", (part.get("name"),
int(part.get("amount"))))
for part in item.findall("./item"))
item_beliefs.append(
agentspeak.Literal(
"item",
(item.get("name"), int(item.get("volume")), tools, parts),
PERCEPT_TAG))
self._replace_beliefs(("item", 4), item_beliefs)
def remove_belief(self, name: str, *args):
"""Remove an existing agent's belief."""
new_args = ()
for x in args:
if type(x) == str:
new_args += (asp.Literal(x),)
else:
new_args += (x,)
term = asp.Literal(name, tuple(new_args), PERCEPT_TAG)
self.agent.bdi_intention_buffer.append((asp.Trigger.removal, asp.GoalType.belief, term,
asp.runtime.Intention()))
def test_request_action(self):
agent = agentspeak.mapc2017.Agent()
with open(os.path.join(os.path.dirname(__file__),
"request-action.xml")) as xml:
agent.message_received(etree.parse(xml).getroot())
term = agentspeak.Literal("money", (50000, ))
intention = agentspeak.runtime.Intention()
self.assertTrue(agent.test_belief(term, intention))
term = agentspeak.Literal(
"shop", ("shop1", 48.8217, 2.33207, 4, agentspeak.Var()))
intention = agentspeak.runtime.Intention()
self.assertTrue(agent.test_belief(term, intention))
agent.dump()
def _string2term(agent, term, intention):
string = asp.grounded(term.args[0], intention.scope)
result = asp.Literal(string)
logger.success("[DBG] {} -> {}".format(string, result))
if asp.unify(term.args[-1], result, intention.scope,
intention.stack):
yield
def connection_lost(self, exc):
LOGGER.warning("socket connection lost (reason: %s)", exc)
self.call(agentspeak.Trigger.removal, agentspeak.GoalType.belief,
agentspeak.Literal("connected", (self.name, )),
agentspeak.runtime.Intention())
self.env.run()
async def run(self):
"""
Coroutine run cyclic.
"""
if self.agent.bdi_enabled:
msg = await self.receive(timeout=0)
if msg:
mdata = msg.metadata
ilf_type = mdata["ilf_type"]
if ilf_type == "tell":
goal_type = asp.GoalType.belief
trigger = asp.Trigger.addition
elif ilf_type == "untell":
goal_type = asp.GoalType.belief
trigger = asp.Trigger.removal
elif ilf_type == "achieve":
goal_type = asp.GoalType.achievement
trigger = asp.Trigger.addition
else:
raise asp.AslError(
"unknown illocutionary force: {}".format(ilf_type))
intention = asp.runtime.Intention()
functor, args = parse_literal(msg.body)
message = asp.Literal(functor, args)
message = asp.freeze(message, intention.scope, {})
tagged_message = message.with_annotation(
asp.Literal("source",
(asp.Literal(str(msg.sender)), )))
self.agent.bdi_intention_buffer.append(
(trigger, goal_type, tagged_message, intention))
if self.agent.bdi_intention_buffer:
temp_intentions = deque(self.agent.bdi_intention_buffer)
for trigger, goal_type, term, intention in temp_intentions:
self.agent.bdi_agent.call(trigger, goal_type, term,
intention)
'''self.agent.bdi_agent.step()'''
self.agent.bdi_intention_buffer.popleft()
self.agent.bdi_agent.step()
else:
await asyncio.sleep(0.1)
def test_unifies_annotated():
X = agentspeak.Var()
Y = agentspeak.Var()
foo_a = agentspeak.Literal("foo", (), ("a",))
foo_ab = agentspeak.Literal("foo", (), ("a", "b"))
foo_XY = agentspeak.Literal("foo", (), (X, Y))
foo_XX = agentspeak.Literal("foo", (), (X, X))
assert agentspeak.unifies_annotated(foo_a, foo_ab)
assert agentspeak.unifies_annotated(foo_a, foo_XY)
assert agentspeak.unifies_annotated(foo_a, foo_XX)
assert agentspeak.unifies_annotated(foo_ab, foo_XY)
assert agentspeak.unifies_annotated(foo_XY, foo_ab)
assert agentspeak.unifies_annotated(foo_XX, foo_ab)
assert agentspeak.unifies_annotated(foo_XX, foo_ab)
assert not agentspeak.unifies_annotated(foo_ab, foo_XX)
def test_unifies_annotated(self):
X = agentspeak.Var()
Y = agentspeak.Var()
foo_a = agentspeak.Literal("foo", (), ("a", ))
foo_ab = agentspeak.Literal("foo", (), ("a", "b"))
foo_XY = agentspeak.Literal("foo", (), (X, Y))
foo_XX = agentspeak.Literal("foo", (), (X, X))
self.assertTrue(agentspeak.unifies_annotated(foo_a, foo_ab))
self.assertTrue(agentspeak.unifies_annotated(foo_a, foo_XY))
self.assertTrue(agentspeak.unifies_annotated(foo_a, foo_XX))
self.assertTrue(agentspeak.unifies_annotated(foo_ab, foo_XY))
self.assertTrue(agentspeak.unifies_annotated(foo_XY, foo_ab))
self.assertTrue(agentspeak.unifies_annotated(foo_XX, foo_ab))
self.assertTrue(agentspeak.unifies_annotated(foo_XX, foo_ab))
self.assertFalse(agentspeak.unifies_annotated(foo_ab, foo_XX))
self.assertFalse(agentspeak.unifies_annotated(foo_XY, foo_a))
def set_belief(self, name: str, *args):
"""Set an agent's belief. If it already exists, updates it."""
new_args = ()
for x in args:
if type(x) == str:
new_args += (asp.Literal(x),)
else:
new_args += (x,)
term = asp.Literal(name, tuple(new_args), PERCEPT_TAG)
found = False
for belief in list(self.agent.bdi_agent.beliefs[term.literal_group()]):
if asp.unifies(term, belief):
found = True
else:
self.agent.bdi_intention_buffer.append((asp.Trigger.removal, asp.GoalType.belief, belief,
asp.runtime.Intention()))
if not found:
self.agent.bdi_intention_buffer.append((asp.Trigger.addition, asp.GoalType.belief, term,
asp.runtime.Intention()))
def test_concat_lists():
env = agentspeak.runtime.Environment()
agent = agentspeak.runtime.Agent(env, "agent")
intention = agentspeak.runtime.Intention()
X = agentspeak.Var()
term = agentspeak.Literal(".concat", ((1, 2), (3, ), X))
next(agentspeak.stdlib._concat(agent, term, intention))
assert X.grounded(intention.scope) == (1, 2, 3)
def test_concat_strings():
env = agentspeak.runtime.Environment()
agent = agentspeak.runtime.Agent(env, "agent")
intention = agentspeak.runtime.Intention()
X = agentspeak.Var()
term = agentspeak.Literal(".concat", ("hello", " ", "world", X))
next(agentspeak.stdlib._concat(agent, term, intention))
assert X.grounded(intention.scope) == "hello world"
def _send(agent, recipient, ils, term):
group = ils.literal_group()
if group == ("tell", 0):
frozen = agentspeak.grounded(term, {}).with_annotation(
agentspeak.Literal("source", (agent.name, )))
agent.emit(recipient,
functools.partial(agentspeak.runtime.add_belief, frozen))
elif group == ("achieve", 0):
frozen = term.with_annotation(
agentspeak.Literal("source", (agent.name, )))
agent.emit(
recipient,
functools.partial(agentspeak.runtime.call,
agentspeak.Trigger.addition,
agentspeak.GoalType.achievement, frozen))
else:
raise agentspeak.PysonError("unsupported illocutionary force: %s/%d" %
(group[0], group[1]))
return True
def _send(agent, term, intention):
# Find the receivers: By a string, atom or list of strings or atoms.
receivers = agentspeak.grounded(term.args[0], intention.scope)
if not agentspeak.is_list(receivers):
receivers = [receivers]
receiving_agents = []
for receiver in receivers:
if agentspeak.is_atom(receiver):
receiving_agents.append(agent.env.agents[receiver.functor])
else:
receiving_agents.append(agent.env.agents[receiver])
# Illocutionary force.
ilf = agentspeak.grounded(term.args[1], intention.scope)
if not agentspeak.is_atom(ilf):
return
if ilf.functor == "tell":
goal_type = agentspeak.GoalType.belief
trigger = agentspeak.Trigger.addition
elif ilf.functor == "untell":
goal_type = agentspeak.GoalType.belief
trigger = agentspeak.Trigger.removal
elif ilf.functor == "achieve":
goal_type = agentspeak.GoalType.achievement
trigger = agentspeak.Trigger.addition
else:
raise agentspeak.AslError("unknown illocutionary force: %s" % ilf)
# TODO: unachieve, askOne, askAll, tellHow, untellHow, askHow
# Prepare message.
message = agentspeak.freeze(term.args[2], intention.scope, {})
tagged_message = message.with_annotation(
agentspeak.Literal("source", (agentspeak.Literal(agent.name), )))
# Broadcast.
for receiver in receiving_agents:
receiver.call(trigger, goal_type, tagged_message,
agentspeak.runtime.Intention())
yield
def do_some_work():
for developer in developers:
if developer.active:
if isinstance(developer, agentspeak.runtime.Agent):
developer.call(agentspeak.Trigger.addition,
agentspeak.GoalType.achievement,
agentspeak.Literal("tick"),
agentspeak.runtime.Intention())
env.run_agent(developer)
else:
developer.do_some_work()
def _set_belief(self, name, *args):
term = agentspeak.Literal(name, tuple(args), PERCEPT_TAG)
found = False
for belief in list(self.beliefs[term.literal_group()]):
if agentspeak.unifies(term, belief):
found = True
else:
self.call(agentspeak.Trigger.removal,
agentspeak.GoalType.belief, belief,
agentspeak.runtime.Intention())
if not found:
self.call(agentspeak.Trigger.addition, agentspeak.GoalType.belief,
term, agentspeak.runtime.Intention())
def _getSquadLeader(agent, term, intention):
##
SQUAD_SIZE = 3 #soldados por escuadra
LEADER_ROLE = "squadleader"
[name, domain] = str(self.name).split("@");
[team, role , user, nnum] = name.split("_");
if len(name.split("_")) != 4:
logger.success("ERROR: {} debe ser equipo_rol_usuario_num".format(name));
nnum = int(name.split("_")[-1]);
#en funcion del numero de agente, asigna lider
#nos hacemos un "Round-robin"
leaderID = "nil";
squadNum = nnum % SQUAD_SIZE;
leaderID = team+"_"+LEADER_ROLE+"_"+user+"_"+str(squadNum)+"@"+domain;
#cadena a literal y "groundea" valor al primer parametro
sqLeader = asp.Literal(leaderID);
if asp.unify(term.args[-1], sqLeader, intention.scope, intention.stack):
yield
def test_unifies():
assert not agentspeak.unifies(True, 1)
assert agentspeak.unifies(3, 3.0)
assert agentspeak.unifies(True, True)
assert agentspeak.unifies(5, agentspeak.Wildcard())
assert agentspeak.unifies((1, 2), (1, agentspeak.Wildcard()))
assert agentspeak.unifies(("hello", 2), ("hello", agentspeak.Var()))
assert agentspeak.unifies(agentspeak.Var(), agentspeak.Literal("beep"))
assert agentspeak.unifies(agentspeak.Literal("boop"), agentspeak.Var())
X = agentspeak.Var()
assert agentspeak.unifies(agentspeak.Literal("foo", (X, X)), agentspeak.Literal("foo", (1, 1)))
assert not agentspeak.unifies(agentspeak.Literal("bar", (X, X)), agentspeak.Literal("bar", (1, 2)))
def test_unifies(self):
self.assertFalse(agentspeak.unifies(True, 1))
self.assertTrue(agentspeak.unifies(3, 3.0))
self.assertTrue(agentspeak.unifies(True, True))
self.assertTrue(agentspeak.unifies(5, agentspeak.Wildcard()))
self.assertTrue(agentspeak.unifies((1, 2), (1, agentspeak.Wildcard())))
self.assertTrue(
agentspeak.unifies(("hello", 2), ("hello", agentspeak.Var())))
self.assertTrue(
agentspeak.unifies(agentspeak.Var(), agentspeak.Literal("beep")))
self.assertTrue(
agentspeak.unifies(agentspeak.Literal("boop"), agentspeak.Var()))
X = agentspeak.Var()
self.assertTrue(
agentspeak.unifies(agentspeak.Literal("foo", (X, X)),
agentspeak.Literal("foo", (1, 1))))
self.assertFalse(
agentspeak.unifies(agentspeak.Literal("bar", (X, X)),
agentspeak.Literal("bar", (1, 2))))
def visit_literal(self, ast_literal):
return agentspeak.Literal(ast_literal.functor,
(t.accept(self) for t in ast_literal.terms),
(t.accept(self)
for t in ast_literal.annotations))
# -*- coding: utf-8 -*-
import asyncio
import time
from ast import literal_eval
from loguru import logger
from collections import deque
import agentspeak as asp
import agentspeak.runtime
from agentspeak.stdlib import actions as asp_action
from spade.behaviour import CyclicBehaviour
from spade.agent import Agent
from spade.template import Template
from spade.message import Message
PERCEPT_TAG = frozenset([asp.Literal("source", (asp.Literal("percept"),))])
class BDIAgent(Agent):
def __init__(self, jid: str, password: str, asl: str, actions=None, *args, **kwargs):
print("ccarstens ccarstens")
self.asl_file = asl
self.bdi_enabled = False
self.bdi_intention_buffer = deque()
self.bdi = None
self.bdi_agent = None
super().__init__(jid, password, *args, **kwargs)
while not self.loop:
time.sleep(0.01)
template = Template(metadata={"performative": "BDI"})
def call_my_plan(agent, txt):
agent.call(
agentspeak.Trigger.addition,
agentspeak.GoalType.achievement,
agentspeak.Literal("my_plan", (txt.upper(), )),
agentspeak.runtime.Intention())
def as_term(self):
return agentspeak.Literal(
"issue",
(agentspeak.Literal(self.type), self.patch, self.priority), ())
def _getSquadLeader(agent, term, intention):
sqLeader = asp.Literal(str(self.name));
if asp.unify(term.args[-1], sqLeader, intention.scope, intention.stack):
yield
import asyncio
from lxml import etree
from heapq import heapify, heappop
import agentspeak
import agentspeak.runtime
import agentspeak.ext_stdlib
LOGGER = agentspeak.get_logger(__name__)
actions = agentspeak.Actions(agentspeak.ext_stdlib.actions)
PERCEPT_TAG = frozenset(
[agentspeak.Literal("source", (agentspeak.Literal("percept"), ))])
class Environment(agentspeak.runtime.Environment):
def time(self):
return asyncio.get_event_loop().time()
def run(self):
super(Environment, self).run()
self.dispatch_wait_until()
def dispatch_wait_until(self):
earliest = None
for agent in self.agents.values():
for intention_stack in agent.intentions:
wait = intention_stack[-1].wait_until
more_work = False
for agent in agents:
more_work |= agent.step(env)
result_file = open("result.csv", "w")
plot = "--plot" in sys.argv
if plot:
plt.ion()
fig = plt.figure()
plt.axis([0, 5 * 365, 0, 600])
for day in range(5 * 365):
term = agentspeak.Literal("day", (day, ))
print(term)
for agent in agents:
agent.call(agentspeak.Trigger.addition,
agentspeak.GoalType.achievement,
env,
term, {},
delayed=True)
run()
print(len(files))
if plot:
import matplotlib.pyplot as plt
def handle_request_action(self, message):
req = message[0]
if self.action_id is not None:
LOGGER.warning("%s: action id %d was not used", self.name,
self.action_id)
self.action_id = int(req.get("id"))
self_data = req.find("self")
self._set_belief("charge", int(self_data.get("charge")))
self._set_belief("load", int(self_data.get("load")))
self._set_belief("lat", float(self_data.get("lat")))
self._set_belief("lon", float(self_data.get("lon")))
self._set_belief("routeLength", int(self_data.get("routeLength", 0)))
route = []
for wp in self_data.findall("./route"):
route.append(
agentspeak.Literal("wp", (int(wp.get("i")), float(
wp.get("lat")), float(wp.get("lon")), PERCEPT_TAG)))
self._set_belief("route", tuple(route))
self._set_belief("money", int(req.find("team").get("money")))
action = self_data.find("action")
if action is not None:
self._set_belief("lastAction",
agentspeak.Literal(action.get("type")))
self._set_belief("lastActionResult",
agentspeak.Literal(action.get("result")))
# TODO: Action parameters
else:
self._replace_beliefs(("lastAction", 1), [])
self._replace_beliefs(("lastActionResult", 1), [])
# Update carried items.
carried_items = []
for item in self_data.findall("./items"):
carried_items.append(
agentspeak.Literal("item",
(item.get("name"), int(item.get("amount"))),
PERCEPT_TAG))
self._replace_beliefs(("item", 2), carried_items)
# Update entities.
entities = []
for entity in req.findall("entity"):
entities.append(
agentspeak.Literal(
"entity", (agentspeak.Literal(entity.get("name")),
entity.get("team"), float(entity.get("lat")),
float(entity.get("lon")),
agentspeak.Literal(entity.get("role").lower())),
PERCEPT_TAG))
self._replace_beliefs(("entity", 5), entities)
# Update charging station pecepts
charging_stations = []
for station in req.findall("chargingStation"):
charging_stations.append(
agentspeak.Literal(
"chargingStation",
(station.get("name"), float(station.get("lat")),
float(station.get("lon")), int(station.get("rate"))),
PERCEPT_TAG))
self._replace_beliefs(("chargingStation", 4), charging_stations)
# Update dumps.
dumps = []
for dump in req.findall("dump"):
dumps.append(
agentspeak.Literal("dump",
(dump.get("name"), float(dump.get("lat")),
float(dump.get("lon"))), PERCEPT_TAG))
self._replace_beliefs(("dump", 4), dumps)
# Update shops.
shops = []
for shop in req.findall("shop"):
shop_items = []
for item in shop.findall("item"):
shop_items.append(
agentspeak.Literal(
"item", (item.get("name"), int(
item.get("price")), int(item.get("amount")))))
shops.append(
agentspeak.Literal(
"shop", (shop.get("name"), float(shop.get("lat")),
float(shop.get("lon")), int(shop.get("restock")),
tuple(shop_items)), PERCEPT_TAG))
self._replace_beliefs(("shop", 5), shops)
# Update storage percepts.
storages = []
for storage in req.findall("storage"):
storage_items = []
for item in storage.findall("item"):
storage_items.append(
agentspeak.Literal(
"item", (item.get("name"), int(
item.get("stored")), int(item.get("delivered")))))
storages.append(
agentspeak.Literal(
"storage",
(storage.get("name"), float(
storage.get("lat")), float(storage.get("lon")),
int(storage.get("totalCapacity")),
int(storage.get("usedCapacity")), tuple(storage_items)),
PERCEPT_TAG))
self._replace_beliefs(("storage", 6), storages)
# Update workshops.
workshops = []
for workshop in req.findall("workshop"):
workshops.append(
agentspeak.Literal(
"workshop",
(workshop.get("name"), float(workshop.get("lat")),
float(workshop.get("lon"))), PERCEPT_TAG))
self._replace_beliefs(("workshop", 3), workshops)
# Update resource nodes.
resource_nodes = []
for node in req.findall("resourceNode"):
resource_nodes.append(
agentspeak.Literal(
"resourceNode",
(node.get("name"), float(node.get("lat")),
float(node.get("lon")), node.get("resource")),
PERCEPT_TAG))
self._replace_beliefs(("resourceNode", 4), resource_nodes)
# Update job percepts.
jobs = []
auctions = []
missions = []
posteds = []
for job in req.findall("job"):
required = tuple(
agentspeak.Literal("required", (item.get("name"),
int(item.get("amount"))))
for item in job.findall("required"))
jobs.append(
agentspeak.Literal(
"job",
(job.get("id"), job.get("storage"), int(job.get("reward")),
int(job.get("start")), int(job.get("end")), required),
PERCEPT_TAG))
for auction in req.findall("auction"):
required = tuple(
agentspeak.Literal("required", (item.get("name"),
int(item.get("amount"))))
for item in auction.findall("required"))
reward = int(auction.get("reward"))
auctions.append(
agentspeak.Literal(
"auction",
(auction.get("id"), auction.get("storage"), reward,
int(auction.get("start")), int(
auction.get("end")), int(auction.get("fine")),
int(auction.get("lowestBid", str(reward + 1))),
int(auction.get("auctionTime")), required), PERCEPT_TAG))
for mission in req.findall("mission"):
required = tuple(
agentspeak.Literal("required", (item.get("name"),
int(item.get("amount"))))
for item in mission.findall("required"))
missions.append(
agentspeak.Literal(
"mission",
(mission.get("id"), mission.get("storage"),
int(mission.get("reward")), int(mission.get("start")),
int(mission.get("end")), int(mission.get("fine")),
int(mission.get("lowestBid")), 0, required), PERCEPT_TAG))
for posted in req.findall("posted"):
required = tuple(
agentspeak.Literal("required", (item.get("name"),
int(item.get("amount"))))
for item in posted.findall("required"))
posteds.append(
agentspeak.Literal(
"job",
(posted.get("id"), posted.get("storage"),
int(posted.get("reward")), int(posted.get("start")),
int(posted.get("end")), required), PERCEPT_TAG))
self._replace_beliefs(("job", 5), jobs)
self._replace_beliefs(("auction", 9), auctions)
self._replace_beliefs(("mission", 9), missions)
self._replace_beliefs(("posted", 5), posteds)
# Update step.
self._set_belief("timestamp", int(message.get("timestamp")))
self._set_belief("deadline", int(req.get("deadline")))
self.simulation_step = int(req.find("simulation").get("step"))
self._set_belief("step", self.simulation_step)