def takeRoad(self, term, intention):
node = pyson.grounded(term.args[0], intention.scope)
nextNode = pyson.grounded(term.args[1], intention.scope)
if not G.has_edge(node, nextNode):
yield False
state = agentStates[self.name]
if state["road"] in [(node, nextNode), (nextNode, node)]:
# stay on road
road = state["road"]
roadData = G[node][nextNode]
state["roadProgress"] += calculateRoadProgress(trafficData[(node,
nextNode)])
if state["roadProgress"] >= roadData["length"]:
trafficData[(node, nextNode)] -= 1
state["node"] = road[1]
state["path"].append(road[1])
state["road"] = None
state["roadProgress"] = 0
yield
# check if road is passable
if G[node][nextNode]["bridge"] and not G[node][nextNode]["bridge"]["open"]:
yield False
print("Agent {} using road ({},{})".format(self.name, node, nextNode))
trafficData[(node, nextNode)] += 1
roadUsedCounter[(str(node), str(nextNode))] += 1
state["node"] = None
state["road"] = (node, nextNode)
state["roadProgress"] = 0
yield
def bridgeStatus(self, term, intention):
node1 = pyson.grounded(term.args[0], intention.scope)
node2 = pyson.grounded(term.args[1], intention.scope)
result = G.get_edge_data(node1, node2)["bridge"]["open"]
if pyson.unify(term.args[2], pyson.Literal("open", (result, )),
intention.scope, intention.stack):
yield
def submit_issue(self, term, intention):
issue = Issue()
issue.author = self.name
issue.type = pyson.grounded(term.args[0], intention.scope)
issue.patch = pyson.grounded(term.args[1], intention.scope)
issue.priority = pyson.grounded(term.args[1], intention.scope)
self.env.issues.insert(0, issue)
yield
def _substring(agent, term, intention):
needle = pyson_str(pyson.grounded(term.args[0], intention.scope))
haystack = pyson_str(pyson.grounded(term.args[1], intention.scope))
choicepoint = object()
pos = haystack.find(needle)
while pos != -1:
intention.stack.append(choicepoint)
if pyson.unify(term.args[2], pos, intention.scope, intention.stack):
yield
pyson.reroll(intention.scope, intention.stack, choicepoint)
pos = haystack.find(needle, pos + 1)
def _broadcast(agent, term, intention):
# Illocutionary force.
ilf = pyson.grounded(term.args[0], intention.scope)
if not pyson.is_atom(ilf):
return
if ilf.functor == "tell":
goal_type = pyson.GoalType.belief
elif ilf.functor == "achieve":
goal_type = pyson.GoalType.achievement
else:
raise pyson.PysonError("unknown illocutionary force: %s" % ilf)
# Prepare message.
message = pyson.freeze(term.args[1], intention.scope, {})
tagged_message = message.with_annotation(
pyson.Literal("source", (pyson.Literal(agent.name), )))
# Broadcast.
for receiver in agent.env.agents.values():
if receiver == agent:
continue
receiver.call(pyson.Trigger.addition, goal_type, tagged_message,
pyson.runtime.Intention())
yield
def nextSteps(self, term, intention):
position = pyson.grounded(term.args[0], intention.scope)
destination = pyson.grounded(term.args[1], intention.scope)
results = []
resetWeights()
for edge in G.edges(position):
road = G[edge[0]][edge[1]]
road["w"] = 1000
for neighbor in G.neighbors(position):
path_length = nx.shortest_path_length(G, neighbor, destination,
"w") + G.get_edge_data(
position, neighbor)["length"]
results.append(pyson.Literal("road", (neighbor, path_length)))
results.sort(key=lambda x: x.args[1])
if pyson.unify(term.args[2], tuple(results), intention.scope,
intention.stack):
yield
def make_patch(self, term, intention):
klass = pyson.grounded(term.args[0], intention.scope)
patch = Patch()
patch.removed.add(klass)
patch.added.add(klass)
if pyson.unify(term.args[1], patch, intention.scope, intention.stack):
yield
def _range_2(agent, term, intention):
choicepoint = object()
for i in range(int(pyson.grounded(term.args[0], intention.scope))):
intention.stack.append(choicepoint)
if pyson.unify(term.args[1], i, intention.scope, intention.stack):
yield
pyson.reroll(intention.scope, intention.stack, choicepoint)
def _concat(agent, term, intention):
args = [pyson.grounded(arg, intention.scope) for arg in term.args[:-1]]
if all(isinstance(arg, (tuple, list)) for arg in args):
result = tuple(el for arg in args for el in arg)
else:
result = "".join(str(arg) for arg in args)
if pyson.unify(term.args[-1], result, intention.scope, intention.stack):
yield
def getDetour(self, term, intention):
target = pyson.grounded(term.args[0], intention.scope)
position = agentStates[self.name]["node"]
edgeData = G.get_edge_data(position, target)
length = edgeData["length"]
edgeData["length"] = 10000
path = nx.shortest_path(G, position, target, "length")[1:]
edgeData["length"] = length
if pyson.unify(term.args[1], tuple(path), intention.scope,
intention.stack):
yield
def _send(agent, term, intention):
# Find the receivers: By a string, atom or list of strings or atoms.
receivers = pyson.grounded(term.args[0], intention.scope)
if not pyson.is_list(receivers):
receivers = [receivers]
receiving_agents = []
for receiver in receivers:
if pyson.is_atom(receiver):
receiving_agents.append(agent.env.agents[receiver.functor])
else:
receiving_agents.append(agent.env.agents[receiver])
# Illocutionary force.
ilf = pyson.grounded(term.args[1], intention.scope)
if not pyson.is_atom(ilf):
return
if ilf.functor == "tell":
goal_type = pyson.GoalType.belief
trigger = pyson.Trigger.addition
elif ilf.functor == "untell":
goal_type = pyson.GoalType.belief
trigger = pyson.Trigger.removal
elif ilf.functor == "achieve":
goal_type = pyson.GoalType.achievement
trigger = pyson.Trigger.addition
else:
raise pyson.PysonError("unknown illocutionary force: %s" % ilf)
# TODO: unachieve, askOne, askAll, tellHow, untellHow, askHow
# Prepare message.
message = pyson.freeze(term.args[2], intention.scope, {})
tagged_message = message.with_annotation(
pyson.Literal("source", (pyson.Literal(agent.name), )))
# Broadcast.
for receiver in receiving_agents:
receiver.call(trigger, goal_type, tagged_message,
pyson.runtime.Intention())
yield
def _send(agent, recipient, ils, term):
group = ils.literal_group()
if group == ("tell", 0):
frozen = pyson.grounded(term, {}).with_annotation(pyson.Literal("source", (agent.name, )))
agent.emit(recipient, functools.partial(pyson.runtime.add_belief, frozen))
elif group == ("achieve", 0):
frozen = term.with_annotation(pyson.Literal("source", (agent.name, )))
agent.emit(recipient, functools.partial(pyson.runtime.call,
pyson.Trigger.addition,
pyson.GoalType.achievement,
frozen))
else:
raise pyson.PysonError("unsupported illocutionary force: %s/%d" % (group[0], group[1]))
return True
def _wait(agent, term, intention):
# Handle optional arguments.
args = [pyson.grounded(arg, intention.scope) for arg in term.args]
if len(args) == 2:
event, millis = args
else:
if pyson.is_number(args[0]):
millis = args[0]
event = None
else:
millis = None
event = args[0]
# Type checks.
if not (millis is None or pyson.is_number(millis)):
raise pyson.PysonError("expected timeout for .wait to be numeric")
if not (event is None or pyson.is_string(event)):
raise pyson.PysonError("expected event for .wait to be a string")
# Event.
if event is not None:
# Parse event.
if not event.endswith("."):
event += "."
log = pyson.Log(LOGGER, 1)
tokens = pyson.lexer.TokenStream(pyson.StringSource("<.wait>", event),
log)
tok, ast_event = pyson.parser.parse_event(tokens.next(), tokens, log)
if tok.lexeme != ".":
raise log.error(
"expected no further tokens after event for .wait, got: '%s'",
tok.lexeme,
loc=tok.loc)
# Build term.
event = ast_event.accept(pyson.runtime.BuildEventVisitor(log))
# Timeout.
if millis is None:
until = None
else:
until = agent.env.time() + millis / 1000
# Create waiter.
intention.waiter = pyson.runtime.Waiter(event=event, until=until)
yield
def _mapc_action(self, term, intention):
if self.action_id is None:
LOGGER.warning("%s already did an action in this step", self.name)
return
message = etree.Element("message")
action = etree.SubElement(message,
"action",
type=term.functor.lstrip("."),
id=str(self.action_id))
for param in term.args:
p = pyson.grounded(param, intention.scope)
if isinstance(p, float) and p.is_integer():
p = int(p)
etree.SubElement(action, "p").text = str(p)
self.send_message(message)
self.action_id = None
yield
def getTraffic(self, term, intention):
target = pyson.grounded(term.args[0], intention.scope)
position = agentStates[self.name]["node"]
destination = agentStates[self.name]["destination"]
road = G[position][target]
state = agentStates[self.name]
resetWeights()
for edge in G.edges(position):
# update information for all incident roads
state["traffic"][edge] = G[edge[0]][
edge[1]]["length"] / calculateRoadProgress(
trafficData[(edge[0], edge[1])])
state["traffic"][(
edge[1],
edge[0])] = G[edge[1]][edge[0]]["length"] / calculateRoadProgress(
trafficData[(edge[1], edge[0])])
for edge, w in state["traffic"].items():
# use agent's known traffic info
G[edge[0]][edge[1]]["w"] = w
path_length = nx.shortest_path_length(G, target, destination,
"w") + road["w"]
if pyson.unify(term.args[1], path_length, intention.scope,
intention.stack):
yield
def commit(self, term, intention):
patch = pyson.grounded(term.args[0], intention.scope)
print("Committing patch", patch)
yield
def _wait(agent, term, intention):
millis = pyson.grounded(term.args[0], intention.scope)
intention.wait_until = agent.env.time() + millis / 1000
yield
def logStep(self, term, intention):
content = pyson.grounded(term.args[0], intention.scope)
traces[self.name].append(content)
yield
def distance(self, term, intention):
n1 = pyson.grounded(term.args[0], intention.scope)
n2 = pyson.grounded(term.args[1], intention.scope)
if pyson.unify(term.args[2], nx.shortest_path_length(G, n1, n2),
intention.scope, intention.stack):
yield
