Python ref.val函数代码示例

    def _key_callback(self, symbol, modifiers, event_time):
        # check the key and time (if this is needed)
        keys = val(self.keys)
        correct_resp = val(self.correct_resp)
        sym_str = key.symbol_string(symbol)
        if None in keys or sym_str in keys:
            # it's all good!, so save it
            self.pressed = sym_str
            self.press_time = event_time

            # fill the base time val
            self.base_time = val(self.base_time_src)
            if self.base_time is None:
                # set it to the state time
                self.base_time = self.state_time
            
            # calc RT if something pressed
            self.rt = event_time['time']-self.base_time

            if self.pressed in correct_resp:
                self.correct = True

            # let's leave b/c we're all done
            #self.interval = 0
            self.leave()

    def _mouse_callback(self, x, y, button, modifiers, event_time):
        # check the mouse and time (if this is needed)
        buttons = val(self.buttons)
        correct_resp = val(self.correct_resp)
        button_str = mouse.buttons_string(button)
        if None in buttons or button_str in buttons:
            # it's all good!, so save it
            self.pressed = button_str
            self.press_time = event_time

            # fill the base time val
            self.base_time = val(self.base_time_src)
            if self.base_time is None:
                # set it to the state time
                self.base_time = self.state_time
            
            # calc RT if something pressed
            self.rt = event_time['time']-self.base_time

            if self.pressed in correct_resp:
                self.correct = True

            # let's leave b/c we're all done
            #self.interval = 0
            self.leave()

    def _enter(self):
        # get the parent enter
        super(Wait, self)._enter()

        # set the duration
        self.duration = random.uniform(val(self.wait_duration),
                                       val(self.wait_duration)+val(self.jitter))

    def _callback(self, dt):
        if self.check:
            self.check = False
            # check the outcome each time
            if not self.outcome:
                # we should stop now
                #self.interval = 0
                self.leave()
                return
                
            # process the children            
            # start those that are not active and not done
            reset_next = False
            num_done = 0
            for i,c in enumerate(self.children):
                if c.done:
                    num_done += 1
                    # set whether we should reset the next
                    reset_next = c.reset_next
                    continue
                if not c.active:
                    if i > 0 and \
                            not self.children[i-1].done and \
                            self.children[i-1].duration < 0:
                        # we have to wait until it's done
                        break

                    # start the next one
                    if reset_next:
                        c.reset_clock = True
                    c.enter()
                    break

                # set whether we should reset the next
                reset_next = c.reset_next

            if num_done == len(self.children):
                # we're done with this sequence
                finished = False
                if not self.iterable is None:
                    # see if we're done with the loop
                    if self.i+1 >= len(val(self.iterable,recurse=False)):
                        # we're really done
                        finished = True
                        self.leave()
                        # reset to start if inside another loop
                        self.i = 0
                    else:
                        # dump log
                        dump([self.get_log()],self.get_log_stream())

                        # set to next
                        self.i += 1
                        self.current.item = val(self.iterable[self.i])
                        
                # update everything for the next loop
                if not finished:
                    self._enter()
                    
        pass

 def _update_callback(self, dt):
     # children must implement drawing the showable to make it shown
     # grab the vstate and associated shown
     vstate = val(self.vstate)
     shown = val(vstate.shown)
     # if something is shown, then delete it
     if shown:
         shown.delete()
     return shown

 def _callback(self, dt):
     # eval the log_items and write the log
     keyvals = [(k,val(v)) for k,v in self.log_items.iteritems()]
     log = dict(keyvals)
     if self.log_dict:
         log.update(val(self.log_dict))
     # log it to the correct file
     dump([log], self._get_stream())
     pass

 def _callback(self, dt):
     if not self.waiting:
         self.exp.window.mouse_callbacks.append(self._mouse_callback)
         self.waiting = True
     wait_duration = val(self.wait_duration)
     if ((wait_duration > 0 and now() >= self.state_time+wait_duration) or
         (val(self.wait_until))):
         # we're done
         self.leave()

    def _enter(self):
        # get the parent enter
        super(Loop, self)._enter()

        # set to current item
        if not self.iterable is None:
            self.current.item = val(self.iterable[self.i])

        # reset outcome so we re-evaluate if called in loop
        self.outcome = val(self.cond)

    def _enter(self):
        if _pyo_server is None:
            # try and init it with defaults
            # print some warning
            init_audio_server()

        # process the vars
        self.duration = val(self.dur)
        self._fader = pyo.Fader(fadein=val(self.fadein), fadeout=val(self.fadeout), 
                                dur=self.duration, mul=val(self.volume))
        self._sine = pyo.Sine(freq=val(self.freq), mul=self._fader).out()

 def _callback(self, dt):
     if not self.waiting:
         self.exp.window.key_callbacks.append(self._key_callback)
         self.waiting = True
     if self.base_time is None:
         self.base_time = val(self.base_time_src)
         if self.base_time is None:
             # set it to the state time
             self.base_time = self.state_time
     wait_duration = val(self.wait_duration)
     if (not wait_duration is None) and (now() >= self.base_time + wait_duration):
         self.leave()
     elif val(self.wait_until):
         self.leave()

    def _enter(self):
        # get the parent enter
        super(Loop, self)._enter()

        # reset outcome so we re-evaluate if called in loop
        self.outcome = val(self.cond)

        # see if shuffle
        if not self.iterable is None and \
           val(self.shuffle) and \
           not self._shuffled:
            # eval and make a shallow copy
            self.iterable = val(self.iterable, recurse=False)[:]
            random.shuffle(self.iterable)
            self._shuffled = True

 def get_log(self):
 	"""
     Evaluate all the log attributes and generate a dict.
     """
     
     keyvals = [(a,val(getattr(self,a))) if hasattr(self,a) 
                else (a,None) for a in self.log_attrs]
     return dict(keyvals)

 def _update_callback(self, dt):
     # children must implement drawing the showable to make it shown
     self.vstate = val(self.vstate)
     self.shown = self.vstate.shown
     self.shown.delete()
     self.shown = None
     self.vstate.shown = None
     return self.shown

    def transform_param(self, name, value):
        value = val(value)

        # normalize color specifier...
        if value is not None and "color" in name:
            return normalize_color_spec(value)
        else:
            return value

 def _enter(self):
     if _pyo_server is None:
         # try and init it with defaults
         # print some warning
         init_audio_server()
     if self.generate_filename:
         self.filename = self.exp.reserve_data_filename("rec", "wav")
         #TODO: when state names are implemented, use state name for file title
     self.filepath = os.path.join(self.exp.subj_dir, val(self.filename))