timing.py

import threading
import time

class TimingManager:
    def __init__(self, time_diff=0.):
        self._time_diff=time_diff
        self.__in_context = False
        self.cb_list = list()
        self.enter_cb_list = list()
        self.pre_exit_cb_list = list()

    def set_time_interval(self, interval):
        if not self.__in_context:
            self._time_diff = interval

    def interval(self, interval):
        self.set_time_interval(interval)
        return self

    def __enter__(self):
        if not self.__in_context:
            self.__last_time = time.time()
            self.__target_time = self.__last_time + self._time_diff
        self.__in_context = True
        for cb in self.enter_cb_list:
            cb()
        return self

    def block(self):
        """Convenience method for inline blocking"""
        with self:
            pass

    def get_remaining(self):
        return self.__target_time - time.time()
    
    def get_elapsed(self):
        return time.time() - self.__last_time

    def __exit__(self, exc_type, exc_val, exc_tb):
        for cb in self.pre_exit_cb_list:
            cb()
        if self.__in_context:
            dt = self.__target_time - time.time()
            if dt > 0:
                time.sleep(dt)
        for cb in self.cb_list:
            cb()
        self.__in_context = False
        
        
    def add_on_exit_callback(self, cb):
        self.cb_list.append(cb)

    def add_pre_exit_callback(self, cb):
        self.pre_exit_cb_list.append(cb)

    def on_enter(self, cb):
        self.enter_cb_list.append(cb)

    def is_in_context(self):
        return self.__in_context