def setUp(self):
self.longMessage = True
self.ph1 = params.ParamHandler()
self.ph2 = params.ParamHandler()
self.ph1.addParam("a", 1, params.ParamTypes.Required)
self.ph2.addParam("b", 2, params.ParamTypes.Required)
msg = """
addValue should add the value and key to the property"""
self.assertEqual({"a": [1]}, paramMapValues(self.ph1), msg)
def test_deserializeParamMap(self):
ph = param.ParamHandler()
ph.addParam("MyDict", dict, param.ParamTypes.Required)
d_ph = param.ParamHandler(
utils.deserializeParamMap(utils.serializeParamMap(ph._params)))
self.assertEqual('MyDict:[] ', d_ph.printState())
ph.addParam("MyList", list, param.ParamTypes.Required)
d_ph = param.ParamHandler(
utils.deserializeParamMap(utils.serializeParamMap(ph._params)))
self.assertEqual('MyDict:[] MyList:[] ', d_ph.printState())
def __init__(self):
"""
@brief An abstract executable skill with a description (type,
label, params, conditions), a state and progress code
"""
# Description
self._id = SkillCore.gen_id.getId()
self._type = ""
self._label = ""
self._description = SkillDescription()
# Params
self._params = params.ParamHandler()
# Conditions
self._pre_conditions = []
self._hold_conditions = []
self._post_conditions = []
# Execution
self._state_change = Event()
self._state = State.Uninitialized
self._avg_time_keeper = TimeKeeper()
self._time_keeper = TimeKeeper()
self._progress_code = 0
self._progress_period = 0.0
self._progress_time = 0.0
self._progress_msg = ""
self._expand_on_start = False
def _autoParametrizeBB(self, skill):
"""
@brief ground undefined parameters with parameters in the Black Board
"""
to_resolve = [
key for key, param in skill._params.getParamMap().iteritems()
if param.paramType != params.ParamTypes.Optional and
param.dataTypeIs(Element) and param.getValue().getIdNumber() < 0
]
if not to_resolve:
return True
log.assertInfo(self._verbose, "[Autoparametrize]",
"Resolving {}:{}".format(skill.type, to_resolve))
#self._importParentsConditions(skill, to_resolve)
remap = {}
cp = params.ParamHandler()
cp.reset(skill._params.getCopy())
for c in skill._pre_conditions:
c.setDesiredState(cp)
for key in to_resolve:
remap[key] = []
for k, p in self._params._params.iteritems():
if p.dataTypeIs(Element()):
if p.getValue().isInstance(cp.getParamValue(key),
self._wm):
remap[key].append(k)
else:
pass # log.info("Not instance", "{} Model: {} Match: {}".format(key, cp.getParamValue(key).printState(True), p.getValue().printState(True)))
return self._autoParametrizeWm(skill, to_resolve, cp)
def __init__(self, wmi, instanciator):
self._wm = wmi
self._simulate = False
self._verbose = False
self._tracked_params = []
self._params = params.ParamHandler()
self._instanciator = instanciator
self._last_print = ""
def getParamsNoRemaps(self):
"""
@brief Get the skill's parameters without key remappings
"""
ph = params.ParamHandler()
ph.reset(self._params.getCopy())
for r1, r2 in reversed(self._remaps.items()):
ph.remap(r2, r1)
return ph
def __init__(self, manager, type_in, name, params_in=None, children=None):
self.manager = manager
self.name = name
self.type = type_in
self.ph = params.ParamHandler()
self.children = list()
if params_in:
self.ph.reset(params_in)
if children:
self.children = children
def __init__(self):
# Description
self._type = "skiros:" + self.__class__.__name__
# Params
self._params = params.ParamHandler()
# Conditions
self._pre_conditions = []
self._hold_conditions = []
self._post_conditions = []
self.createDescription()
self.generateDefParams()
def test_serialize_ParamMap(self):
ph = param.ParamHandler()
ph.addParam("MyDict", dict, param.ParamTypes.Required)
s_param_map = utils.serializeParamMap(ph._params)
self.assertSameItems(s_param_map_strings[0], str(s_param_map))
ph.addParam("MyList", list, param.ParamTypes.Required)
s_param_map = utils.serializeParamMap(ph._params)
self.assertSameItems(s_param_map_strings[1], str(s_param_map))
params = {}
params["MyDict"] = param.Param("MyDict", "", dict,
param.ParamTypes.Required)
s_param_map = utils.serializeParamMap(params)
self.assertSameItems(s_param_map_strings[0], str(s_param_map))
params = {}
params["MyString"] = param.Param("MyString", "", "String",
param.ParamTypes.Required)
s_param_map = utils.serializeParamMap(params)
self.assertSameItems(s_param_map_strings[2], str(s_param_map))
def __init__(self):
# Description
self._id = SkillCore.gen_id.getId()
self._type = ""
self._label = ""
self._description = SkillDescription()
# Params
self._params = params.ParamHandler()
# Conditions
self._pre_conditions = []
self._hold_conditions = []
self._post_conditions = []
# Execution
self._state_change = Event()
self._state = State.Uninitialized
self._time_keeper = TimeKeeper()
self._progress_code = 0
self._progress_period = 0.0
self._progress_time = 0.0
self._progress_msg = ""
self._expand_on_start = False
def initProblem(self):
objects = {}
elements = {}
self._elements = {}
# Find objects
for objType in self._pddl_interface._types._types["thing"]:
temp = self._wmi.resolve_elements(wmi.Element(objType))
elements[objType] = temp
if len(temp) > 0:
objects[objType] = []
for e in temp:
objects[objType].append(e.id)
self._elements[e.id] = e
self._elements[e.id.lower()] = e
for e in self._abstract_objects:
ctype = self._wmi.get_super_class(e.type)
if ctype not in objects:
objects[ctype] = []
elements[ctype] = []
e._id = e.label
if not e.label in objects[ctype]: # Avoids duplicates
objects[ctype].append(e._label)
elements[ctype].append(e)
self._elements[e.id] = e
self._elements[e.id.lower()] = e
self._pddl_interface.setObjects(objects)
# Evaluate inital state
for supertype, types in self._pddl_interface._types._types.items():
elements[supertype] = []
for t in types:
elements[supertype] += elements[t]
params = skirosp.ParamHandler()
params.addParam("x", Element(), skirosp.ParamTypes.Required)
params.addParam("y", Element(), skirosp.ParamTypes.Required)
for p in self._pddl_interface._predicates:
if self._wmi.get_reasoner(p.name) is not None:
# The predicate is handled by a reasoner
xtype = p.params[0]["valueType"]
ytype = p.params[1]["valueType"]
for xe in elements[xtype]:
for ye in elements[ytype]:
relations = self._wmi.get_reasoner(
p.name).computeRelations(xe, ye)
if self._verbose:
log.info(
"[Checking {}-{}-{}]".format(
xe.id, p.name, ye.id),
" Got: {}".format(relations))
if p.name in relations:
self._pddl_interface.addInitState(
pddl.GroundPredicate(p.name, [xe.id, ye.id]))
else:
# The predicate is handled normally
if len(p.params) == 1:
if p.value != None:
c = cond.ConditionProperty("", p.name, "x", p.operator,
p.value, True)
else:
c = cond.ConditionHasProperty("", p.name, "x", True)
xtype = p.params[0]["valueType"]
for xe in elements[xtype]:
params.specify("x", xe)
if c.evaluate(params, self._wmi):
self._pddl_interface.addInitState(
pddl.GroundPredicate(p.name, [xe._id],
p.operator, p.value))
else:
xtype = p.params[0]["valueType"]
ytype = p.params[1]["valueType"]
subx = [xtype] if self._pddl_interface.getSubTypes(
xtype) is None else self._pddl_interface.getSubTypes(
xtype)
suby = [ytype] if self._pddl_interface.getSubTypes(
ytype) is None else self._pddl_interface.getSubTypes(
ytype)
if p.abstracts:
query_str_template = """
SELECT ?x ?y WHERE {{
{{ ?xtypes rdfs:subClassOf* {xtype}. }} UNION {{ {xtype} rdfs:subClassOf* ?xtypes. }}
{{ ?ytypes rdfs:subClassOf* {ytype}. }} UNION {{ {ytype} rdfs:subClassOf* ?ytypes. }}
?xtypes rdfs:subClassOf ?restriction . ?restriction owl:onProperty {relation}. ?restriction ?quantity ?ytypes.
?x rdf:type/rdfs:subClassOf* ?xtypes. ?y rdf:type/rdfs:subClassOf* ?ytypes.
}}"""
else:
query_str_template = """
SELECT ?x ?y WHERE {{
{{ ?x {relation} ?y. ?x rdf:type/rdfs:subClassOf* {xtype}. ?y rdf:type/rdfs:subClassOf* {ytype}.}}
UNION
{{?t {relation} ?z. ?t rdf:type/rdfs:subClassOf* {xtype}. ?z rdf:type/rdfs:subClassOf* {ytype}. ?t skiros:hasTemplate ?x. ?z skiros:hasTemplate ?y. }}
UNION
{{?t {relation} ?y. ?t rdf:type/rdfs:subClassOf* {xtype}. ?y rdf:type/rdfs:subClassOf* {ytype}. ?t skiros:hasTemplate ?x.}}
UNION
{{?x {relation} ?z. ?x rdf:type/rdfs:subClassOf* {xtype}. ?z rdf:type/rdfs:subClassOf* {ytype}. ?z skiros:hasTemplate ?y.}}
}}"""
for x in subx:
for y in suby:
query_str = query_str_template.format(
relation=p.name, xtype=x, ytype=y)
answer = self._wmi.query_ontology(query_str)
for line in answer:
tokens = line.strip().split(" ")
self._pddl_interface.addInitState(
pddl.GroundPredicate(p.name, tokens))
for p in self._pddl_interface._functions:
c = cond.ConditionProperty("", p.name, "x", p.operator, p.value,
True)
xtype = p.params[0]["valueType"]
for xe in elements[xtype]:
params.specify("x", xe)
if c.evaluate(params, self._wmi):
self._pddl_interface.addInitState(
pddl.GroundPredicate(p.name, [xe._id], p.operator,
p.value))
if self._verbose:
log.info("[Problem]", self._pddl_interface.printProblem(False))
