示例#1
0
 def verify_parameters(self):
     """Perform type check on all parameters"""
     for parameter_name in dir(self.parameters):
         if parameter_name.startswith("__"):
             continue
         require_type = self.get_specified_type(parameter_name)
         this_type = ve_types.get_type(getattr(self.parameters, parameter_name))
         ve_types.assert_type(this_type, require_type)
示例#2
0
 def verify_parameters(self):
     """Perform type check on all parameters"""
     for parameter_name in dir(self.parameters):
         if parameter_name.startswith('__'):
             continue
         require_type = self.get_specified_type(parameter_name)
         this_type = ve_types.get_type(getattr(self.parameters,parameter_name))
         ve_types.assert_type(this_type,require_type)
示例#3
0
def assert_type(*args):
    warnings.warn(
        "VisionEgg.assert_type() has been moved to " + "VisionEgg.ParameterTypes.assert_type()",
        DeprecationWarning,
        stacklevel=2,
    )
    return ve_types.assert_type(*args)
示例#4
0
    def set(self, **kw):
        """Set a parameter with type-checked value

        This is the slow but safe way to set parameters.  It is recommended to
        use this method in all but speed-critical portions of code.
        """
        # Note that we don't overload __setattr__ because that would always slow
        # down assignment, not just when it was convenient.
        #
        # (We could make a checked_parameters attribute though.)
        for parameter_name in kw.keys():
            setattr(self.parameters, parameter_name, kw[parameter_name])
            require_type = self.get_specified_type(parameter_name)
            value = kw[parameter_name]
            this_type = ve_types.get_type(value)
            ve_types.assert_type(this_type, require_type)
            setattr(self.parameters, parameter_name, value)
示例#5
0
    def set(self, **kw):
        """Set a parameter with type-checked value

        This is the slow but safe way to set parameters.  It is recommended to
        use this method in all but speed-critical portions of code.
        """
        # Note that we don't overload __setattr__ because that would always slow
        # down assignment, not just when it was convenient.
        #
        # (We could make a checked_parameters attribute though.)
        for parameter_name in kw.keys():
            setattr(self.parameters, parameter_name, kw[parameter_name])
            require_type = self.get_specified_type(parameter_name)
            value = kw[parameter_name]
            this_type = ve_types.get_type(value)
            ve_types.assert_type(this_type, require_type)
            setattr(self.parameters, parameter_name, value)
示例#6
0
 def __do_assignment_command(self,tcp_name,command,require_type):
     new_contained_controller = None
     match = SocketListenController._re_const.match(command)
     if match is not None:
         try:
             match_groups = self.__get_five_args(match.group(1))
             kw_args = {}
             kw_args['during_go_value'] = match_groups[0]
             if match_groups[1] is not None:
                 kw_args['between_go_value'] = match_groups[1]
             self.__process_common_args(kw_args,match_groups)
             kw_args.setdefault('return_type',require_type)
             new_contained_controller = VisionEgg.FlowControl.ConstantController(**kw_args)
             new_type = new_contained_controller.returns_type()
             ve_types.assert_type( new_type, require_type)
         except Exception, x:
             import traceback
             traceback.print_exc()
             self.socket.send("Error %s parsing const for %s: %s\n"%(x.__class__,tcp_name,x))
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.info("%s parsing const for %s: %s"%(x.__class__,tcp_name,x))
示例#7
0
 def __do_assignment_command(self, tcp_name, command, require_type):
     new_contained_controller = None
     match = SocketListenController._re_const.match(command)
     if match is not None:
         try:
             match_groups = self.__get_five_args(match.group(1))
             kw_args = {}
             kw_args['during_go_value'] = match_groups[0]
             if match_groups[1] is not None:
                 kw_args['between_go_value'] = match_groups[1]
             self.__process_common_args(kw_args, match_groups)
             kw_args.setdefault('return_type', require_type)
             new_contained_controller = VisionEgg.FlowControl.ConstantController(
                 **kw_args)
             new_type = new_contained_controller.returns_type()
             ve_types.assert_type(new_type, require_type)
         except Exception, x:
             import traceback
             traceback.print_exc()
             self.socket.send("Error %s parsing const for %s: %s\n" %
                              (x.__class__, tcp_name, x))
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.info("%s parsing const for %s: %s" %
                         (x.__class__, tcp_name, x))
示例#8
0
         new_contained_controller = VisionEgg.FlowControl.EvalStringController(
             **kw_args)
         if not (new_contained_controller.eval_frequency
                 & VisionEgg.FlowControl.Controller.NOT_DURING_GO):
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.debug('Executing "%s" as safety check.' %
                          (kw_args['during_go_eval_string'], ))
             new_contained_controller._test_self(1)
         if not (new_contained_controller.eval_frequency
                 & VisionEgg.FlowControl.Controller.NOT_BETWEEN_GO):
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.debug('Executing "%s" as safety check.' %
                          (kw_args['between_go_eval_string'], ))
             new_contained_controller._test_self(0)
         new_type = new_contained_controller.returns_type()
         ve_types.assert_type(new_type, require_type)
     except Exception, x:
         new_contained_controller = None
         self.socket.send("Error %s parsing eval_str for %s: %s\n" %
                          (x.__class__, tcp_name, x))
         logger = logging.getLogger('VisionEgg.TCPController')
         logger.info("%s parsing eval_str for %s: %s" %
                     (x.__class__, tcp_name, x))
 else:
     match = SocketListenController._re_exec_str.match(command)
     if match is not None:
         try:
             kw_args = {}
             match_groups = match.groups()
             if match_groups[0] == '*':
                 kw_args['restricted_namespace'] = 0
示例#9
0
def assert_type(*args):
    warnings.warn("VisionEgg.assert_type() has been moved to "+\
                  "VisionEgg.ParameterTypes.assert_type()",
                  DeprecationWarning, stacklevel=2)
    return ve_types.assert_type(*args)
示例#10
0
         kw_args['during_go_eval_string'] = string.replace(match_groups[0],r"\n","\n")
         if match_groups[1] is not None:
             kw_args['between_go_eval_string'] = string.replace(match_groups[1],r"\n","\n")
         self.__process_common_args(kw_args,match_groups)
         kw_args.setdefault('return_type',require_type)
         new_contained_controller = VisionEgg.FlowControl.EvalStringController(**kw_args)
         if not (new_contained_controller.eval_frequency & VisionEgg.FlowControl.Controller.NOT_DURING_GO):
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.debug('Executing "%s" as safety check.'%(kw_args['during_go_eval_string'],))
             new_contained_controller._test_self(1)
         if not (new_contained_controller.eval_frequency & VisionEgg.FlowControl.Controller.NOT_BETWEEN_GO):
             logger = logging.getLogger('VisionEgg.TCPController')
             logger.debug('Executing "%s" as safety check.'%(kw_args['between_go_eval_string'],))
             new_contained_controller._test_self(0)
         new_type = new_contained_controller.returns_type()
         ve_types.assert_type( new_type, require_type)
     except Exception, x:
         new_contained_controller = None
         self.socket.send("Error %s parsing eval_str for %s: %s\n"%(x.__class__,tcp_name,x))
         logger = logging.getLogger('VisionEgg.TCPController')
         logger.info("%s parsing eval_str for %s: %s"%(x.__class__,tcp_name,x))
 else:
     match = SocketListenController._re_exec_str.match(command)
     if match is not None:
         try:
             kw_args = {}
             match_groups = match.groups()
             if match_groups[0] == '*':
                 kw_args['restricted_namespace'] = 0
             else:
                 kw_args['restricted_namespace'] = 1