def run(self):
        """Execute events until the queue is empty.
        When there is a positive delay until the first event, the
        delay function is called and the event is left in the queue;
        otherwise, the event is removed from the queue and executed
        (its action function is called, passing it the argument).  If
        the delay function returns prematurely, it is simply
        restarted.
        It is legal for both the delay function and the action
        function to modify the queue or to raise an exception;
        exceptions are not caught but the scheduler's state remains
        well-defined so run() may be called again.
        A questionable hack is added to allow other threads to run:
        just after an event is executed, a delay of 0 is executed, to
        avoid monopolizing the CPU when other threads are also
        runnable.
        """
        # localize variable access to minimize overhead
        # and to improve thread safety
        q = self._queue
        delayfunc = self.delayfunc
        timefunc = self.timefunc
        pop = heapq.heappop
        while q:
            # TODO: modified part of grumpy version.
            checked_event = q[0]
            time, priority, action, argument = checked_event.get_fields()
            now = timefunc()
            if now < time:
                delayfunc(time - now)
            else:
                event = pop(q)
                # Verify that the event was not removed or altered
                # by another thread after we last looked at q[0].
                if event is checked_event:
                    action(*argument)
                    delayfunc(0)   # Let other threads run
                else:
                    heapq.heappush(q, event)
def run(self):
        """Execute events until the queue is empty.
        When there is a positive delay until the first event, the
        delay function is called and the event is left in the queue;
        otherwise, the event is removed from the queue and executed
        (its action function is called, passing it the argument).  If
        the delay function returns prematurely, it is simply
        restarted.
        It is legal for both the delay function and the action
        function to modify the queue or to raise an exception;
        exceptions are not caught but the scheduler's state remains
        well-defined so run() may be called again.
        A questionable hack is added to allow other threads to run:
        just after an event is executed, a delay of 0 is executed, to
        avoid monopolizing the CPU when other threads are also
        runnable.
        """
        # localize variable access to minimize overhead
        # and to improve thread safety
        q = self._queue
        delayfunc = self.delayfunc
        timefunc = self.timefunc
        pop = heapq.heappop
        while q:
            # TODO: modified part of grumpy version.
            checked_event = q[0]
            time, priority, action, argument = checked_event.get_fields()
            now = timefunc()
            if now < time:
                delayfunc(time - now)
            else:
                event = pop(q)
                # Verify that the event was not removed or altered
                # by another thread after we last looked at q[0].
                if event is checked_event:
                    action(*argument)
                    delayfunc(0)   # Let other threads run
                else:
                    heapq.heappush(q, event)
def run ( self ) : # localize variable access to minimize overhead # and to improve thread safety q = self . _queue delayfunc = self . delayfunc timefunc = self . timefunc pop = heapq . heappop while q : # TODO: modified part of grumpy version. checked_event = q [ 0 ] time , priority , action , argument = checked_event . get_fields ( ) now = timefunc ( ) if now < time : delayfunc ( time - now ) else : event = pop ( q ) # Verify that the event was not removed or altered # by another thread after we last looked at q[0]. if event is checked_event : action ( * argument ) delayfunc ( 0 ) # Let other threads run else : heapq . heappush ( q , event )
Execute events until the queue is empty.
        When there is a positive delay until the first event, the
        delay function is called and the event is left in the queue;
        otherwise, the event is removed from the queue and executed
        (its action function is called, passing it the argument).  If
        the delay function returns prematurely, it is simply
        restarted.
        It is legal for both the delay function and the action
        function to modify the queue or to raise an exception;
        exceptions are not caught but the scheduler's state remains
        well-defined so run() may be called again.
        A questionable hack is added to allow other threads to run:
        just after an event is executed, a delay of 0 is executed, to
        avoid monopolizing the CPU when other threads are also
        runnable.
Execute events until the queue is empty . When there is a positive delay until the first event the delay function is called and the event is left in the queue ; otherwise the event is removed from the queue and executed ( its action function is called passing it the argument ) . If the delay function returns prematurely it is simply restarted . It is legal for both the delay function and the action function to modify the queue or to raise an exception ; exceptions are not caught but the scheduler s state remains well - defined so run () may be called again . A questionable hack is added to allow other threads to run : just after an event is executed a delay of 0 is executed to avoid monopolizing the CPU when other threads are also runnable .