def __ground_method(parameters, subtasks, ordering, task, problem, depth):
task = signs[task]
stasks = {}
task_signifs = []
for tasknum, subtask in subtasks.items():
signifs = __ground_single_method(parameters, subtask, problem, depth)
if signifs:
stasks[tasknum] = signifs
else:
return None
if len(stasks) == 1:
signifs = stasks['task0']
for signif in signifs:
task_signif = task.add_significance()
connector = task_signif.add_feature(signif)
signif.sign.add_out_significance(connector)
task_signifs.append(task_signif)
else:
variants = mix_pairs(stasks)
for variant in variants:
task_signif = task.add_significance()
for order in ordering:
signif = variant[order]
connector = task_signif.add_feature(signif)
signif.sign.add_out_significance(connector)
task_signifs.append(task_signif)
return task_signifs
def preactivate_action_nonspecial(act_signif, constraints, plagent):
"""
This function activate nonspecial (common for all agents) actions
"""
I_sign = signs['I']
act_roles = {
net[2].sign
for net in act_signif.spread_down_activity('significance', 5)
}
for ag, constraint in constraints.items():
predicates = set()
signatures = []
for predicate in constraint:
predicates.add(predicate.name)
signatures.append(predicate.signature)
role_signifs = {}
for signature in signatures:
for signa in signature:
roles = {
cm.sign
for cm in signs[signa].spread_up_activity_obj(
'significance', 2) if cm.sign in act_roles
}
for role in roles:
if signa == plagent:
signa = 'I'
role_signifs.setdefault(role, set()).add(signs[signa])
variants = mix_pairs(role_signifs)
for variant in variants:
act_mean = act_signif.copy('significance', 'meaning')
for role_sign, obj in variant.items():
if obj not in obj_means:
obj_mean = obj_signifs[obj].copy('significance', 'meaning')
else:
obj_mean = obj_means[obj]
act_mean.replace('meaning', role_sign, obj_mean)
if ag == plagent:
connector = act_mean.add_feature(obj_means[I_sign])
efconnector = act_mean.add_feature(obj_means[I_sign],
effect=True)
I_sign.add_out_meaning(connector)
else:
ag_mean = obj_means[signs[ag]]
connector = act_mean.add_feature(ag_mean)
efconnector = act_mean.add_feature(ag_mean, effect=True)
signs[ag].add_out_meaning(connector)
def specialized(action, signs, obj_means, obj_signifs, act_signif, agent,
constraints):
agent_signs = []
agents_with_constraints = []
for ag in action.agents:
for cm in signs[ag].significances.values():
agent_signs.extend(list(
cm.get_signs())) #add current agents's signs
for ag in constraints.keys():
agents_with_constraints.append(signs[ag])
agent_roles = {}
# receiving all agent's roles.
for ag in agent_signs:
for a in ag.get_role():
if a.name != "object":
agent_roles.setdefault(ag, set()).update(a.get_role())
for ag in agent_roles.keys():
act_mean = act_signif.copy('significance', 'meaning')
role_signs = [
sign for sign in act_mean.get_signs() if sign in agent_roles[ag]
]
for role_sign in role_signs: # changing agent's roles to agents cms
if role_sign in act_mean.get_signs():
ag_mean = obj_means[ag]
act_mean.replace('meaning', role_sign, ag_mean)
if ag in agents_with_constraints:
predicates = []
for _, preds in constraints[ag.name].items():
predicates.extend(preds)
role_signifs = {}
non_agent_preds = []
agent_preds = []
for pred in predicates:
for signa in pred.signature:
if signa[0] == ag.name:
agent_preds.append(
pred) # predicates with agent signature
break
else:
continue
else:
non_agent_preds.append(
pred) # predicates without agent signature
agent_signs = []
for predicate in agent_preds:
agent_signs.extend([
signa[0] for signa in predicate.signature
if signa[0] != ag.name
])
for pred in non_agent_preds.copy():
signatures = []
for signa in pred.signature:
signatures.append(signa[0])
if not any(signa in agent_signs for signa in signatures):
non_agent_preds.remove(pred)
non_agent_preds_signs = {
signs[pred.name]
for pred in non_agent_preds
}
for event in itertools.chain(act_mean.cause, act_mean.effect):
event_signs = event.get_signs()
if ag in event_signs:
pred_signs = [
pred for pred in predicates
if signs[pred.name] in event_signs
]
if pred_signs:
event_signs.remove(ag)
for pred in pred_signs:
role_signature = {
sign
for sign in event_signs
if sign != signs[pred.name]
}
for role in role_signature:
pred_roles = [
signif.get_signs() for _, signif in
role.significances.items()
]
pred_role = set()
while len(pred_roles):
for role1 in pred_roles.copy():
role2 = list(role1)[0]
if not role2 in pred_role:
pred_role.add(role2)
pred_roles.remove(role1)
else:
pred_roles.remove(role1)
# matrixe role to predicate's type
role_signifs.setdefault(
role, set()).update(pred_role)
# change type sign to object sign
for key, pred_signats in role_signifs.items():
for pred_signat in pred_signats.copy():
for signa in pred.signature:
if signa[1][
0].name == pred_signat.name:
pred_signats.remove(pred_signat)
pred_signats.add(signs[signa[0]])
elif event_signs & non_agent_preds_signs:
for predicate in non_agent_preds:
pred_signats = {
signs[signa[0]]
for signa in predicate.signature
}
if role_signifs:
used_signs = reduce(lambda x, y: x | y,
role_signifs.values())
else:
used_signs = set()
new_signs = pred_signats - used_signs
for pred_sign in new_signs:
attributes = pred_sign.find_attribute()
key_at = None
depth = 2
while depth > 0:
for attribute in attributes:
if not attribute in event_signs:
attribute = attribute.find_attribute()
for at in attribute.copy():
if at in event_signs:
key_at = at
break
else:
depth -= 1
break
break
if key_at:
role_signifs.setdefault(key_at,
set()).add(pred_sign)
if 'truck' not in action.name and 'airplane' not in action.name:
obj_signs = signs['block?x'], signs['block?y']
for obj_sign in obj_signs:
if obj_sign in role_signifs.keys():
role_signifs.pop(obj_sign)
pairs = mix_pairs(role_signifs)
if pairs:
for pair in pairs:
act_mean_constr = act_mean.copy('meaning', 'meaning')
for role_sign, obj in pair.items():
if obj not in obj_means:
obj_mean = obj_signifs[obj].copy(
'significance', 'meaning')
else:
obj_mean = obj_means[obj]
act_mean_constr.replace('meaning', role_sign, obj_mean)
if ag.name == agent:
I_sign = signs["I"]
connector = act_mean_constr.add_feature(
obj_means[I_sign])
efconnector = act_mean_constr.add_feature(
obj_means[I_sign], effect=True)
I_sign.add_out_meaning(connector)
else:
ag_mean = obj_means[ag]
connector = act_mean_constr.add_feature(ag_mean)
efconnector = act_mean_constr.add_feature(ag_mean,
effect=True)
ag.add_out_meaning(connector)
else:
if ag.name == agent:
I_sign = signs["I"]
connector = act_mean.add_feature(obj_means[I_sign])
efconnector = act_mean.add_feature(obj_means[I_sign],
effect=True)
I_sign.add_out_meaning(connector)
else:
ag_mean = obj_means[ag]
connector = act_mean.add_feature(ag_mean)
efconnector = act_mean.add_feature(ag_mean, effect=True)
ag.add_out_meaning(connector)
def _generate_meanings(self, chains, sm=None):
def __get_role_index(chain):
index = 0
rev_chain = reversed(chain)
for el in rev_chain:
if len(el.cause) == 0:
continue
elif len(el.cause) == 1:
if len(el.cause[0].coincidences) ==1:
index = chain.index(el)
else:
return index
else:
return index
return None
def __generator(combinations, pms, pm_signs, pm, agent):
for combination in combinations:
cm = pm.copy('meaning', 'meaning')
for role_sign, obj_pm in combination.items():
if role_sign in pm_signs:
if obj_pm.sign in pm_signs:
continue
obj_cm = obj_pm.copy('significance', 'meaning')
cm.replace('meaning', role_sign, obj_cm)
if not pms:
pms.append((agent, cm))
else:
for _, pmd in copy(pms):
if pmd.resonate('meaning', cm):
break
else:
pms.append((agent, cm))
return pms
replace_map = {}
main_pm = None
for chain in chains:
role_index = __get_role_index(chain)
if role_index:
if not chain[role_index].sign in replace_map:
replace_map[chain[role_index].sign] = [chain[-1]]
else:
if not chain[-1] in replace_map[chain[role_index].sign]:
replace_map[chain[role_index].sign].append(chain[-1])
main_pm = chain[0]
connectors = [agent.out_meanings for agent in self.agents]
main_pm_len = len(main_pm.cause) + len(main_pm.effect) + 2
mapped_actions = {}
for agent_con in connectors:
for con in agent_con:
if con.in_sign == main_pm.sign:
mapped_actions.setdefault(con.out_sign, set()).add(con.in_sign.meanings[con.in_index])
new_map = {}
rkeys = {el for el in replace_map.keys()}
pms = []
for agent, lpm in mapped_actions.items():
for pm in lpm.copy():
if len(pm.cause) + len(pm.effect) != main_pm_len:
lpm.remove(pm)
continue
pm_signs = set()
pm_mean = pm.spread_down_activity('meaning', 3)
for pm_list in pm_mean:
pm_signs |= set([c.sign for c in pm_list])
role_signs = rkeys & pm_signs
if not role_signs:
lpm.remove(pm)
if not pms:
pms.append((agent, pm))
else:
for _, pmd in copy(pms):
if pmd.resonate('meaning', pm):
break
else:
pms.append((agent, pm))
if not sm:
for agent, lpm in mapped_actions.items():
for pm in lpm:
if len(pm.cause) + len(pm.effect) != main_pm_len:
continue
pm_signs = set()
pm_mean = pm.spread_down_activity('meaning', 3)
for pm_list in pm_mean:
pm_signs |= set([c.sign for c in pm_list])
role_signs = rkeys & pm_signs
for role_sign in role_signs:
new_map[role_sign] = replace_map[role_sign]
combinations = mix_pairs(new_map)
pms = __generator(combinations, pms, pm_signs, pm, agent)
else:
sm_chains = sm.spread_down_activity('meaning', A_C)
sm_signs = set()
for chain in sm_chains:
sm_signs |= set([c.sign for c in chain])
changed_signs = set()
for role, rms in replace_map.items():
changed_signs |= {cm.sign for cm in rms if cm.sign in sm_signs}
for agent, actions in mapped_actions.items():
for action in actions:
act_chains = action.spread_down_activity('meaning', A_C)
act_signs = set()
for chain in act_chains:
act_signs |= set([c.sign for c in chain])
combinations = mix_pairs(replace_map)
pms = __generator(combinations, pms, act_signs, action, agent)
for pair in pms.copy():
pm_chains = pair[1].spread_down_activity('meaning', A_C)
pm_signs = set()
for chain in pm_chains:
pm_signs |= set([c.sign for c in chain])
if not pm_signs.issuperset(changed_signs):
pms.remove(pair)
return pms