def string2Method(self, method_string, robots): """ Return the HandlerMethodConfig according to the input string from configEditor This functions must be located in HandlerSubsystem in order to get access to handler_configs dictionary method_string: a string that stores the information of a method configObj for example: a = "nao_maeby.NaoSensorHandler.seePerson(name='nao', test=[1,2,3])" robots: a list of robots in the current experiment config. we need this to find the robot type and avaliable handlers based on robot_name """ if not self.handler_configs: logging.error("Cannot find handler_configs dictionary, please load all handlers first.") return None try: call_descriptors, _ = parseCallString(method_string, mode="single") if len(call_descriptors[0].name) != 3: raise SyntaxError("Name must be in form of '<robot_name>.<handler_name>.<method_name>'") except SyntaxError: logging.exception("Cannot parse setting {!r}".format(method_string)) return None robot_name, handler_name, method_name = call_descriptors[0].name # find which handler does this method belongs to handler_config = None if robot_name == "share": # this is a dummy sensor/actuator for h in self.handler_configs["share"][ht.SensorHandler] + \ self.handler_configs["share"][ht.ActuatorHandler]: if h.name == handler_name: handler_config = h break else: # this is a robot sensor/actuator for robot_config in robots: if robot_config.name == robot_name: handler_config = robot_config.getHandlerByName(handler_name) break # we did not find the correct handler config if handler_config is None: logging.error("Cannot recognize handler {!r} of robot {!r}".format(handler_name, robot_name)) logging.error("Please make sure it is correctly loaded") return None # try to find the method config try: method_config = deepcopy(handler_config.getMethodByName(method_name)) except ValueError: return None # update parameters of this method method_config.updateParaFromDict(call_descriptors[0].args) return method_config
def createPropositionMappingExecutionFunctionFromString(self, func_string, mode): """ Given a string description of the function(s) that some proposition maps to, create the appropriate HandlerMethodConfigs and return the function that will evaluate their execute() methods. """ # Call the parser with appropriate arguments call_descriptors, eval_function = parseCallString(func_string, mode, self._makeHandlerMethodConfigAndGetExecutionFunction) # Return the resulting function to be evaluated return eval_function
def createPropositionMappingExecutionFunctionFromString( self, func_string, mode): """ Given a string description of the function(s) that some proposition maps to, create the appropriate HandlerMethodConfigs and return the function that will evaluate their execute() methods. """ # Call the parser with appropriate arguments call_descriptors, eval_function = parseCallString( func_string, mode, self._makeHandlerMethodConfigAndGetExecutionFunction) # Return the resulting function to be evaluated return eval_function
def fromString(cls, para_string): """ Create a MethodParameterConfig from a single line of a comment from a handler method. para_string: string specifying the properties of the parameter """ # Regular expression to help us out # NOTE: The description does not permit parentheses argRE = re.compile( '^\s*(?P<argName>\w+)\s*\(\s*(?P<type>\w+)\s*\)\s*:\s*(?P<description>[^\(]+)\s*(?P<settings>\(.+\))?\s*$', re.IGNORECASE) # Try to match m = argRE.search(para_string) if m is None: raise ValueError("Not a properly-formatted parameter description.") new_obj = cls(name=m.group('argName'), para_type=m.group('type'), desc=m.group('description')) if m.group('settings') is not None: # To make valid Python syntax, we just need to prepend # a dummy function name before the settings string try: call_desc, _ = parseCallString("dummy_function" + m.group("settings"), mode="single") except SyntaxError as e: raise SyntaxError( "Error while parsing settings for parameter {!r}: {}". format(m.group('argName'), e)) settings = call_desc[0].args # Set all of the settings for k, v in settings.iteritems(): if k.lower() not in [ 'default', 'min_val', 'max_val', 'options', 'min', 'max' ]: raise SyntaxError( "Unrecognized setting name {!r} for parameter {!r}". format(k.lower(), m.group('argName'))) setattr(new_obj, k.lower(), v) new_obj.resetValue() return new_obj
def fromString(cls, para_string): """ Create a MethodParameterConfig from a single line of a comment from a handler method. para_string: string specifying the properties of the parameter """ # Regular expression to help us out # NOTE: The description does not permit parentheses argRE = re.compile('^\s*(?P<argName>\w+)\s*\(\s*(?P<type>\w+)\s*\)\s*:\s*(?P<description>[^\(]+)\s*(?P<settings>\(.+\))?\s*$', re.IGNORECASE) # Try to match m = argRE.search(para_string) if m is None: raise ValueError("Not a properly-formatted parameter description.") new_obj = cls(name=m.group('argName'), para_type=m.group('type'), desc=m.group('description')) if m.group('settings') is not None: # To make valid Python syntax, we just need to prepend # a dummy function name before the settings string try: call_desc, _ = parseCallString("dummy_function"+m.group("settings"), mode="single") except SyntaxError as e: raise SyntaxError("Error while parsing settings for parameter {!r}: {}".format(m.group('argName'), e)) settings = call_desc[0].args # Set all of the settings for k, v in settings.iteritems(): if k.lower() not in ['default', 'min_val', 'max_val', 'options', 'min', 'max']: raise SyntaxError("Unrecognized setting name {!r} for parameter {!r}".format(k.lower(), m.group('argName'))) setattr(new_obj, k.lower(), v) new_obj.resetValue() return new_obj
def fromData(self, robot_data, hsub): """ Given a dictionary of robot handler information, returns a robot object holding all the information The dictionary is in the format returned by the readFromFile function If the necessary handler of the robot is not specified or can't be loaded, return None """ # update robot name and type try: self.name = robot_data['RobotName'][0] except (KeyError, IndexError): raise ht.LoadingError("Cannot find robot name") self._setLoadFailureFlag() try: self.r_type = robot_data['Type'][0] except (KeyError, IndexError): raise ht.LoadingError("Cannot find robot type") self._setLoadFailureFlag() # update robot calibration matrix if 'CalibrationMatrix' in robot_data: self.calibration_matrix = self._getCalibrationMatrixFromString(''.join(robot_data['CalibrationMatrix'])) # load handler configs for key, val in robot_data.iteritems(): # Ignore config sections that aren't for handlers if not key.endswith('Handler'): continue # Find the intended type of the handler try: handler_type = ht.getHandlerTypeClass(key) except KeyError: logging.warning('Cannot recognize handler type {!r} for robot {}({})'.format(key, self.name, self.r_type)) self._setLoadFailureFlag() continue # Go through the handler listings for this type for handler_config_str in val: # Parse this line try: call_descriptors, _ = parseCallString(handler_config_str, mode="single") except SyntaxError: # This is an invalid handler config description logging.exception('Cannot recognize handler config description: \n \t {!r} \n \ for handler type {!r} of robot {}({})'.format(handler_config_str, key, self.name, self.r_type)) self._setLoadFailureFlag() continue # Figure out how to interpret the different parts of the CallDescriptor name if len(call_descriptors[0].name) == 3: robot_type, h_type, handler_name = call_descriptors[0].name # 3-part name is only valid for shared handlers if robot_type != 'share': raise SyntaxError("Name must be in form of 'share.<handler_type>.<handler_name>' or '<robot_type>.<handler_name>'") elif len(call_descriptors[0].name) == 2: robot_type, handler_name = call_descriptors[0].name h_type = None else: raise SyntaxError("Name must be in form of 'share.<handler_type>.<handler_name>' or '<robot_type>.<handler_name>'") # Check that this handler belongs to this robot (it's kind of redundant that the `robot_type` must be # specified if we're only going to let it be one value...) if (robot_type != 'share') and (robot_type.lower() != self.r_type.lower()): # this is a handler for a wrong robot logging.warning('The handler config description: \n \t {!r} \n \ is for robot {}, but is located in data for robot {}({})' \ .format(handler_config_str, robot_type, self.name, self.r_type)) self._setLoadFailureFlag() continue # if the description also specifies the handler type in it # we need to make sure it matches with the handler type we get from section name if h_type is not None: # get the handler type as class object try: handler_type_from_str = ht.getHandlerTypeClass(h_type) except KeyError: logging.warning('Cannot recognize handler type {!r} in config description: \n \t {!r} \n \ for robot {}({})'.format(h_type, handler_config_str, self.name, self.r_type)) self._setLoadFailureFlag() continue if handler_type_from_str != handler_type: # the handler type from the description does not match the one from section name logging.warning('Misplaced handler description: \n \t {!r} \n \ in handler type {!r} for robot {}({})' \ .format(handler_config_str, handler_type, self.name, self.r_type)) # we still want to put this handler config into the right type handler_type = handler_type_from_str if robot_type == 'share' and h_type is None: # This is a shared handler but no handler type information is given logging.warning('Handler type info missing for {!r} handler in config description: \n \t {!r} \n \ for robot {}({})'.format(robot_type, handler_config_str, self.name, self.r_type)) self._setLoadFailureFlag() continue # now let's get the handler config object based on the info we have got handler_config = hsub.getHandlerConfigDefault(robot_type, handler_type, handler_name) # make sure it successfully loaded if handler_config is None: self._setLoadFailureFlag() continue # load all parameter values and overwrite the ones in the __init__ method of default handler config object try: init_method_config = handler_config.getMethodByName('__init__') except ValueError: logging.warning('Cannot update default parameters of default handler config {!r}'.format(handler_config.name)) else: init_method_config.updateParaFromDict(call_descriptors[0].args) # if it is successfully fetched, we save it at the corresponding handler type of this robot if handler_type not in self.handlers: # This type of handler has not been loaded yet self.handlers[handler_type] = handler_config else: # This type of handler has been loaded, for now, we will NOT overwrite it with new entry # A warning will be shown logging.warning('Multiple handler configs are detected for handler type {!r} of robot {}({}). \ Will only load the first one.'.format(key, self.name, self.r_type)) break
def string2Method(self, method_string, robots): """ Return the HandlerMethodConfig according to the input string from configEditor This functions must be located in HandlerSubsystem in order to get access to handler_configs dictionary method_string: a string that stores the information of a method configObj for example: a = "nao_maeby.NaoSensorHandler.seePerson(name='nao', test=[1,2,3])" robots: a list of robots in the current experiment config. we need this to find the robot type and avaliable handlers based on robot_name """ if not self.handler_configs: logging.error( "Cannot find handler_configs dictionary, please load all handlers first." ) return None try: call_descriptors, _ = parseCallString(method_string, mode="single") if len(call_descriptors[0].name) != 3: raise SyntaxError( "Name must be in form of '<robot_name>.<handler_name>.<method_name>'" ) except SyntaxError: logging.exception( "Cannot parse setting {!r}".format(method_string)) return None robot_name, handler_name, method_name = call_descriptors[0].name # find which handler does this method belongs to handler_config = None if robot_name == "share": # this is a dummy sensor/actuator for h in self.handler_configs["share"][ht.SensorHandler] + \ self.handler_configs["share"][ht.ActuatorHandler]: if h.name == handler_name: handler_config = h break else: # this is a robot sensor/actuator for robot_config in robots: if robot_config.name == robot_name: handler_config = robot_config.getHandlerByName( handler_name) break # we did not find the correct handler config if handler_config is None: logging.error("Cannot recognize handler {!r} of robot {!r}".format( handler_name, robot_name)) logging.error("Please make sure it is correctly loaded") return None # try to find the method config try: method_config = deepcopy( handler_config.getMethodByName(method_name)) except ValueError: return None # update parameters of this method method_config.updateParaFromDict(call_descriptors[0].args) return method_config