def __init__(self, identifier, text):
self.identifier = identifier
self.text = text
self.parsed = AGMFileDataParsing.fromText(text)
self.plannerCode = self.parsed.getAGGLPlannerCode(
skipPassiveRules=True)
self.module = self.getModuleFromText(self.plannerCode).RuleSet()
def parse_domain(self, fileName):
'''
A parser function for files with .aggl extension
'''
agmData = AGMFileDataParsing.fromFile(fileName)
for rule in agmData.agm.rules:
self.action_list.append(rule.name)
def parse_domain(self, fileName):
'''
A parser for Domain Files (.aggl extension)
This reads domain file and gathers knowledge about action_list which contains all possible actions:
'''
agmData = AGMFileDataParsing.fromFile(fileName)
for rule in agmData.agm.rules:
self.action_list.append(rule.name)
"""
Sacamos el nombre de la regla jerarquica
nombreRegla @ { x:y x:y ...} \n
n n+1 n+2 len-2 len-1
"""
f = open(ficheroPlan, "r")
reglaJerarquica = f.readline()
f.close()
finNombre = reglaJerarquica.find("@")
nombreRegla = reglaJerarquica[:finNombre]
""" Aplicamos la regla sobre el mundo de origen y guardamos el resultado en un fichero temporal. Para ello, debemos... """
"1) pasar el dominio de AGGL a PY"
agmData = AGMFileDataParsing.fromFile(ficheroDominio)
agmData.generateAGGLPlannerCode("/tmp/domain.py", skipPassiveRules=True)
dominioPython = "/tmp/domain.py"
"2) Sacamos del dominio el conjunto de reglas"
dominioFinal = imp.load_source('domain', dominioPython).RuleSet()
mapaReglas = copy.deepcopy(dominioFinal.getRules())
"3) Preparamos el grafo de inicio"
mundoInicio = WorldStateHistory(xmlModelParser.graphFromXML(ficheroMundo))
mundoInicio.nodeId = 0
"4) Del mapa de reglas buscamos nuestra regla jerarquica y la aplicamos. Guardamos el resultado en un XML"
for resultado in mapaReglas[nombreRegla](mundoInicio): print ' '
resultado.graph.toXML("/tmp/resultado.xml")
"5) Del fichero resultado tenemos que poner los nuevos nodos creados como variables no como constantes, para que el programa funcione: "
ficheroPlan = sys.argv[
3] # Fichero P con el plan para alcanzar el mundo target.
"""
Sacamos el nombre de la regla jerarquica
nombreRegla @ { x:y x:y ...} \n
n n+1 n+2 len-2 len-1
"""
f = open(ficheroPlan, "r")
reglaJerarquica = f.readline()
f.close()
finNombre = reglaJerarquica.find("@")
nombreRegla = reglaJerarquica[:finNombre]
""" Aplicamos la regla sobre el mundo de origen y guardamos el resultado en un fichero temporal. Para ello, debemos... """
"1) pasar el dominio de AGGL a PY"
agmData = AGMFileDataParsing.fromFile(ficheroDominio)
agmData.generateAGGLPlannerCode("/tmp/domain.py",
skipPassiveRules=True)
dominioPython = "/tmp/domain.py"
"2) Sacamos del dominio el conjunto de reglas"
dominioFinal = imp.load_source('domain', dominioPython).RuleSet()
mapaReglas = copy.deepcopy(dominioFinal.getRules())
"3) Preparamos el grafo de inicio"
mundoInicio = WorldStateHistory(
xmlModelParser.graphFromXML(ficheroMundo))
mundoInicio.nodeId = 0
"4) Del mapa de reglas buscamos nuestra regla jerarquica y la aplicamos. Guardamos el resultado en un XML"
for resultado in mapaReglas[nombreRegla](mundoInicio):
def __init__(self, identifier, text):
self.identifier = identifier
self.text = text
self.module = self.getModuleFromText(self.code).CheckTarget
self.code = generateTarget_AGGT(
self.module, AGMFileDataParsing.targetFromText(text))
if __name__ == '__main__': # program domain problem result
#from pycallgraph import *
#from pycallgraph.output import GraphvizOutput
#graphviz = GraphvizOutput()
#graphviz.output_file = 'basic.png'
if True:
#with PyCallGraph(output=graphviz):
from parseAGGL import AGMFileDataParsing #AGMFileDataParsing en fichero parseAGGL.py
t0 = time.time()
if len(sys.argv) < 6:
print 'Usage\n\t', sys.argv[
0], ' domainFile.aggl activeRules.py init.xml target.xml.py trainFile [result.plan] [input_hierarchical.plan]'
else:
domainAGM = AGMFileDataParsing.fromFile(
sys.argv[1]) #From domain.aggl
domainPath = sys.argv[2] # ActiveRules.py path
initPath = sys.argv[3] # Inital model or world.
targetPath = sys.argv[4] # Target model or world.
trainFile = sys.argv[5] # Sorting actions by relevance
resultFile = None
if len(sys.argv) >= 7: resultFile = open(sys.argv[6], 'w')
hierarchicalInputPlan = None
if len(sys.argv) >= 8:
hierarchicalInputPlan = open(sys.argv[7], 'r')
domainRuleSet = imp.load_source('module__na_me',
domainPath).RuleSet()
targetCode = imp.load_source('modeeeule__na_me',
targetPath).CheckTarget
targetVariablesCode = imp.load_source(
#!/usr/bin/env pypy
import sys, traceback
sys.path.append('/usr/local/share/agm/')
import xmlModelParser
from AGGL import *
from parseAGGL import AGMFileDataParsing
from agglplanner import *
if __name__ == '__main__': # program domain problem result
if len(sys.argv)<4:
print 'Usage\n\t', sys.argv[0], ' domain.aggl init.xml rulename [param1:value1 [param2:value2 [...]]]'
else:
agmData = AGMFileDataParsing.fromFile(sys.argv[1])
params = dict()
for i in xrange(4, len(sys.argv)):
param = sys.argv[i].split(':')
params[param[0]] = param[1]
#params = eval(sys.argv[4])
domainPath = "/tmp/domain.py"
domain = imp.load_source('domain', domainPath).RuleSet()
# aggl py-domain init target indent params exclude write-plan
p = PyPlan(agmData, domainPath, sys.argv[2], domain.getHierarchicalTargets()[sys.argv[3]], '', params, [sys.argv[3]], None)
def parse_target(self, fileName):
agmData = AGMFileDataParsing.targetFromFile(fileName)
print(agmData['graph'].nodes)
print(agmData['graph'].links)
'''
Parse files with .aggt extension, target files (with respect to planner not classifier)
'''
self.attr_node = []
self.attr_link = []
# Keep tracks of keys used to represent some object type
var_map = {}
f = open(fileName)
flag = False
for line in f:
if "{" in line:
flag = True
elif "}" in line:
# Preconditions are not considered while learning.
break
if flag:
if ":" in line:
line = line.split(":")
final_type = line[1].split("(")[0].strip()
line[0] = line[0].strip()
# If id is given, initial type is matched to type of id
if line[0].isdigit():
init_type = self.typeMap[int(line[0])]
else:
''' If id is not given, initial type is assumed to be same as final type
and the mapping is recorded.
'''
init_type = final_type
var_map[line[0]] = final_type
self.attr_node.append((init_type, final_type))
elif "->" in line:
line = line.split("->")
temp = line[1].split("(")
# line[0] basically represents src id
line[0] = line[0].strip()
# temp[0] basically represents dst id.
temp[0] = temp[0].strip()
# rel stores relations between two id's.
rel = temp[1].split(")")[0].strip()
# There can be four cases, src id is int/symbol or dst id is int/symbol
if line[0].isdigit() and temp[0].isdigit():
id1 = int(line[0])
id2 = int(temp[0])
id_pair = (id1, id2)
type1 = self.typeMap[id1]
type2 = self.typeMap[id2]
self.attr_link.append((type1, rel, type2))
if id_pair in self.relMap:
for relation in self.relMap[id_pair]:
self.attr_link.append((type1, relation, type2))
self.attr_link.append(
(type1, relation, rel, type2))
else:
if not line[0].isdigit():
if not temp[0].isdigit():
type1 = var_map[line[0]]
type2 = var_map[temp[0]]
self.attr_link.append((type1, rel, type2))
for id_pair in self.relMap:
if type1 == self.typeMap[id_pair[
0]] and type2 == self.typeMap[
id_pair[1]]:
for relation in self.relMap[id_pair]:
self.attr_link.append(
(type1, relation, type2))
self.attr_link.append(
(type1, relation, rel, type2))
else:
id2 = int(temp[0])
type1 = var_map[line[0]]
type2 = self.typeMap[id2]
self.attr_link.append((type1, rel, type2))
for id_pair in self.relMap:
if self.typeMap[id_pair[
0]] == type1 and id_pair[1] == id2:
for relation in self.relMap[id_pair]:
self.attr_link.append(
(type1, relation, type2))
self.attr_link.append(
(type1, relation, rel, type2))
else:
id1 = int(line[0])
type1 = self.typeMap[id1]
type2 = var_map[temp[0]]
self.attr_link.append((type1, rel, type2))
for id_pair in self.relMap:
if id_pair[0] == id1 and self.typeMap[
id_pair[1]] == type2:
for relation in self.relMap[id_pair]:
self.attr_link.append(
(type1, relation, type2))
self.attr_link.append(
(type1, relation, rel, type2))
print(self.attr_node)
print(self.attr_link)
f.close()
#!/usr/bin/env pypy
import sys, traceback
sys.path.append('/usr/local/share/agm/')
import xmlModelParser
from AGGL import *
from parseAGGL import AGMFileDataParsing
from agglplanner import *
if __name__ == '__main__': # program domain problem result
if len(sys.argv) < 4:
print 'Usage\n\t', sys.argv[
0], ' domain.aggl init.xml rulename [param1:value1 [param2:value2 [...]]]'
else:
agmData = AGMFileDataParsing.fromFile(sys.argv[1])
params = dict()
for i in xrange(4, len(sys.argv)):
param = sys.argv[i].split(':')
params[param[0]] = param[1]
#params = eval(sys.argv[4])
domainPath = "/tmp/domain.py"
domain = imp.load_source('domain', domainPath).RuleSet()
# aggl py-domain init target indent params exclude write-plan
p = PyPlan(agmData, domainPath, sys.argv[2],
domain.getHierarchicalTargets()[sys.argv[3]], '', params,
[sys.argv[3]], None)
for other in self.knownNodes: if deriv == other: if other.cost <= deriv.cost: return True return False if __name__ == '__main__': # program domain problem result #from pycallgraph import * #from pycallgraph.output import GraphvizOutput #graphviz = GraphvizOutput() #graphviz.output_file = 'basic.png' if True: #with PyCallGraph(output=graphviz): from parseAGGL import AGMFileDataParsing #AGMFileDataParsing en fichero parseAGGL.py t0 = time.time() if len(sys.argv)<5: print 'Usage\n\t', sys.argv[0], ' domain.aggl activeRules.py init.xml target.xml.py [result.plan]' else: domainAGM = AGMFileDataParsing.fromFile(sys.argv[1]) #From domain.aggl domainPath = sys.argv[2] # Get the activeRules.py path init = sys.argv[3] # Get the inital model or world. targetPath = sys.argv[4] # Get the target model or world. resultFile = None if len(sys.argv)>=6: resultFile = open(sys.argv[5], 'w') p = PyPlan(domainAGM, domainPath, init, targetPath, '', dict(), [], resultFile) print 'Tiempo Total: ', (time.time()-t0).__str__()