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))