Fixes for issue #142.

Changed TickRepeat/TickRepeatStatus to Repeat/RepeatStatus to match Delay class naming convention.

Added time_remaining/time_elapsed properties to Delay class.

Added execute_on_start argument to Repeat.start to know if the function needs to be executed before any delays occur.

Changed Repeat properties remaining, count, limit, and elapsed to remaining_loops, loop_count, loop_limit, and time_elapsed to better describe what the property is for.

Added Repeat properties delay_time_remaining/delay_time_elapsed to return the values for the current delay.

Author: satoon101

addons/source-python/packages/source-python/listeners/tick.py

@@ -32,8 +32,8 @@
 # =============================================================================
 __all__ = ('Delay',
            'GameThread',
-           'TickRepeat',
-           'TickRepeatStatus',
+           'Repeat',
+           'RepeatStatus',
            )
 
 
@@ -122,7 +122,8 @@ def __init__(self, delay, callback, *args, **kwargs):
             raise ValueError('Given callback is not callable.')
 
         self.delay = delay
-        self.exec_time = time.time() + delay
+        self._start_time = time.time()
+        self.exec_time = self._start_time + delay
         self.callback = callback
         self.args = args
         self.kwargs = kwargs
@@ -153,6 +154,20 @@ def running(self):
         """Return True if the delay running."""
         return self in _delay_manager
 
+    @property
+    def time_remaining(self):
+        if not self.running:
+            # TODO: what should we return here, or should we raise an error?
+            return None
+        return self.exec_time - time.time()
+
+    @property
+    def time_elapsed(self):
+        if not self.running:
+            # TODO: what should we return here, or should we raise an error?
+            return None
+        return time.time() - self._start_time
+
     def _unload_instance(self):
         with suppress(ValueError):
             self.cancel()
@@ -161,15 +176,15 @@ def _unload_instance(self):
 # =============================================================================
 # >> REPEAT CLASSES
 # =============================================================================
-class TickRepeatStatus(IntEnum):
-    """Class used to store TickRepeatStatus values."""
+class RepeatStatus(IntEnum):
+    """Class used to store RepeatStatus values."""
 
     STOPPED = 1
     RUNNING = 2
     PAUSED = 3
 
 
-class TickRepeat(AutoUnload):
+class Repeat(AutoUnload):
     """Class used to create and call repeats."""
 
     def __init__(self, callback, *args, **kwargs):
@@ -181,41 +196,41 @@ def __init__(self, callback, *args, **kwargs):
 
         # Log the __init__ message
         listeners_tick_logger.log_debug(
-            'TickRepeat.__init__: <{0}> <{1}> <{2}>'.format(
+            'Repeat.__init__: <{0}> <{1}> <{2}>'.format(
                 self.callback, self.args, self.kwargs))
 
         # Set up private attributes
         self._interval = 0
         self._limit = 0
         self._count = 0
         self._adjusted = 0
-        self._status = TickRepeatStatus.STOPPED
+        self._status = RepeatStatus.STOPPED
         self._delay = None
         self._loop_time = None
 
-    def start(self, interval, limit):
+    def start(self, interval, limit, execute_on_start=False):
         """Start the repeat loop."""
         # Log the start message
         listeners_tick_logger.log_debug(
-            'TickRepeat.start: <{0}> <{1}>'.format(interval, limit))
+            'Repeat.start: <{0}> <{1}>'.format(interval, limit))
 
         # Is the repeat already running?
-        if self._status is TickRepeatStatus.RUNNING:
+        if self._status is RepeatStatus.RUNNING:
 
             # Log the status
             listeners_tick_logger.log_debug(
-                'TickRepeat.start - TickRepeatStatus.RUNNING')
+                'Repeat.start - RepeatStatus.RUNNING')
 
             # Do not start the repeat
             return
 
         # Log starting the repeat
         listeners_tick_logger.log_debug(
-            'TickRepeat.start - !TickRepeatStatus' +
-            '.RUNNING - Starting TickRepeat')
+            'Repeat.start - !RepeatStatus' +
+            '.RUNNING - Starting Repeat')
 
         # Set the status to running
-        self._status = TickRepeatStatus.RUNNING
+        self._status = RepeatStatus.RUNNING
 
         # Set the given attributes
         self._interval = interval
@@ -228,35 +243,39 @@ def start(self, interval, limit):
         # Start the delay
         self._delay = Delay(self._interval, self._execute)
 
+        # Call the callback if set to execute on start
+        if execute_on_start:
+            self.callback(*self.args, **self.kwargs)
+
     def stop(self):
         """Stop the repeat loop."""
         # Log the stop message
-        listeners_tick_logger.log_debug('TickRepeat.stop')
+        listeners_tick_logger.log_debug('Repeat.stop')
 
         # Is the repeat running?
-        if self._status is not TickRepeatStatus.RUNNING:
+        if self._status is not RepeatStatus.RUNNING:
 
             # Log the status
             listeners_tick_logger.log_debug(
-                'TickRepeat.stop - !TickRepeatStatus.RUNNING')
+                'Repeat.stop - !RepeatStatus.RUNNING')
 
             # No need to stop it
             return
 
         # Log stopping the repeat
         listeners_tick_logger.log_debug(
-            'TickRepeat.stop - TickRepeatStatus.RUNNING - Stopping TickRepeat')
+            'Repeat.stop - RepeatStatus.RUNNING - Stopping Repeat')
 
         # Set the status to stopped
-        self._status = TickRepeatStatus.STOPPED
+        self._status = RepeatStatus.STOPPED
 
         # Cancel the delay
         self._delay.cancel()
 
     def restart(self):
         """Restart the repeat."""
         # Log restarting the repeat
-        listeners_tick_logger.log_debug('TickRepeat.restart')
+        listeners_tick_logger.log_debug('Repeat.restart')
 
         # Stop the repeat
         self.stop()
@@ -270,24 +289,24 @@ def pause(self):
         Pausing allows the repeat to be resumed.
         """
         # Log the pause message
-        listeners_tick_logger.log_debug('TickRepeat.pause')
+        listeners_tick_logger.log_debug('Repeat.pause')
 
         # Is the repeat running?
-        if self._status is not TickRepeatStatus.RUNNING:
+        if self._status is not RepeatStatus.RUNNING:
 
             # Log the status
             listeners_tick_logger.log_debug(
-                'TickRepeat.pause - !TickRepeatStatus.RUNNING')
+                'Repeat.pause - !RepeatStatus.RUNNING')
 
             # No need to pause
             return
 
         # Log pausing the repeat
         listeners_tick_logger.log_debug(
-            'TickRepeat.pause - TickRepeatStatus.RUNNING - Pausing TickRepeat')
+            'Repeat.pause - RepeatStatus.RUNNING - Pausing Repeat')
 
         # Set the status to paused
-        self._status = TickRepeatStatus.PAUSED
+        self._status = RepeatStatus.PAUSED
 
         # Set the remaining time in the current loop
         self._loop_time = self._delay.exec_time - time.time()
@@ -301,40 +320,40 @@ def resume(self):
         Can only resume if in paused status.
         """
         # Log the resume message
-        listeners_tick_logger.log_debug('TickRepeat.resume')
+        listeners_tick_logger.log_debug('Repeat.resume')
 
         # Is the repeat paused?
-        if self._status is not TickRepeatStatus.PAUSED:
+        if self._status is not RepeatStatus.PAUSED:
 
             # Log the status
             listeners_tick_logger.log_debug(
-                'TickRepeat.resume - !TickRepeatStatus.PAUSED')
+                'Repeat.resume - !RepeatStatus.PAUSED')
 
             # Do not resume
             return
 
         # Log resuming the repeat
         listeners_tick_logger.log_debug(
-            'TickRepeat.resume - TickRepeatStatus.' +
-            'PAUSED - Resuming TickRepeat')
+            'Repeat.resume - RepeatStatus.' +
+            'PAUSED - Resuming Repeat')
 
         # Set the status to running
-        self._status = TickRepeatStatus.RUNNING
+        self._status = RepeatStatus.RUNNING
 
         # Start the delay
         self._delay = Delay(self._loop_time, self._execute)
 
     def extend(self, adjustment):
         """Add to the number of loops to be made."""
         # Log the extend message
-        listeners_tick_logger.log_debug('TickRepeat.extend')
+        listeners_tick_logger.log_debug('Repeat.extend')
 
         # Is there a limit for this repeat?
-        if not self.limit:
+        if not self.loop_limit:
 
             # Log a message about no reducing
             listeners_tick_logger.log_debug(
-                'Unable to extend, TickRepeat instance has no limit.')
+                'Unable to extend, Repeat instance has no limit.')
 
             # No need to go further
             return
@@ -351,14 +370,14 @@ def extend(self, adjustment):
     def reduce(self, adjustment):
         """Reduce the number of loops to be made."""
         # Log the reduce message
-        listeners_tick_logger.log_debug('TickRepeat.reduce')
+        listeners_tick_logger.log_debug('Repeat.reduce')
 
         # Is there a limit for this repeat?
-        if not self.limit:
+        if not self.loop_limit:
 
             # Log a message about no reducing
             listeners_tick_logger.log_debug(
-                'Unable to reduce, TickRepeat instance has no limit.')
+                'Unable to reduce, Repeat instance has no limit.')
 
             # No need to go further
             return
@@ -373,41 +392,41 @@ def reduce(self, adjustment):
         self._adjusted -= adjustment
 
         # Are no more loops to be made?
-        if (self.remaining <= 0 and
-                self.status is TickRepeatStatus.RUNNING):
+        if (self.remaining_loops <= 0 and
+                self.status is RepeatStatus.RUNNING):
 
             # Log the reduce-stopping message
             listeners_tick_logger.log_debug(
-                'TickRepeat.reduce - Reduce caused repeat to stop')
+                'Repeat.reduce - Reduce caused repeat to stop')
 
             # Stop the repeat
             self.stop()
 
     def _execute(self):
         """Execute the repeat's callback with its arguments and keywords."""
         # Log the _execute message
-        listeners_tick_logger.log_debug('TickRepeat._execute')
+        listeners_tick_logger.log_debug('Repeat._execute')
 
         # Add one to the current count
         self._count += 1
 
         # Are any more loops to be made?
-        if self.remaining or not self._limit:
+        if self.remaining_loops or not self._limit:
 
             # Is there no limit?
             if not self._limit:
 
                 # Log continuing the loop
                 listeners_tick_logger.log_debug(
-                    'TickRepeat._execute - No limit')
+                    'Repeat._execute - No limit')
 
             # Is there a limit?
             else:
 
                 # Log continuing the loop
                 listeners_tick_logger.log_debug(
-                    'TickRepeat._execute - Remaining - {0}'.format(
-                        self.remaining))
+                    'Repeat._execute - Remaining - {0}'.format(
+                        self.remaining_loops))
 
             # Call the delay again
             self._delay = Delay(self._interval, self._execute)
@@ -417,16 +436,16 @@ def _execute(self):
 
             # Log stopping the repeat
             listeners_tick_logger.log_debug(
-                'TickRepeat._execute - Stopping the loop')
+                'Repeat._execute - Stopping the loop')
 
             # Set the status to stopped
-            self._status = TickRepeatStatus.STOPPED
+            self._status = RepeatStatus.STOPPED
 
         # Call the repeat's callback
         self.callback(*self.args, **self.kwargs)
 
     @property
-    def remaining(self):
+    def remaining_loops(self):
         """Return the remaining number of loops in the repeat."""
         # Is there no limit?
         if not self._limit:
@@ -435,15 +454,15 @@ def remaining(self):
             return self._limit
 
         # Return the remaining number of loops
-        return self.limit - self._count
+        return self.loop_limit - self._count
 
     @property
-    def count(self):
+    def loop_count(self):
         """Return the current number of loops made in the repeat."""
         return self._count
 
     @property
-    def limit(self):
+    def loop_limit(self):
         """Return the total number of loops to be made."""
         # Is there no limit?
         if not self._limit:
@@ -455,25 +474,36 @@ def limit(self):
         return self._limit + self._adjusted
 
     @property
-    def timeleft(self):
+    def time_left(self):
         """Return the remaining time till the end of the repeat."""
-        return self.remaining * self._interval
+        return (
+            self.remaining_loops * self._interval +
+            self.delay_time_remaining
+        )
 
     @property
-    def elapsed(self):
+    def time_elapsed(self):
         """Return the elapsed time since the repeat started."""
-        return self._count * self._interval
+        return self.total_time - self.time_left
 
     @property
     def total_time(self):
         """Return the total time it will take to complete the repeat."""
-        return self.limit * self._interval
+        return self.loop_limit * self._interval
 
     @property
     def status(self):
         """Return the status of the repeat."""
         return self._status
 
+    @property
+    def delay_time_remaining(self):
+        return self._delay.time_remaining
+
+    @property
+    def delay_time_elapsed(self):
+        return self._delay.time_elapsed
+
     def _unload_instance(self):
         """Stop the repeat with being unloaded."""
         self.stop()