TaskScheduler

import time
import traceback
import sys

class NumberFactory(object):
    def __init__(self, starting_value):
        self.value = starting_value

    def increment(self):
        self.value += 1
        print(self.value)

    def decrement(self):
        self.value -= 1
        print(self.value)

    def square(self):
        self.value = self.value ** 2
        print(self.value)



class TaskScheduler(object):
    def __init__(self, obj, max_runtime=None):
        self.obj = obj
        self.max_runtime = max_runtime
        self.taskList = []

    def add_task(self, fun, seconds=1.0, minutes=0.0, hours=0.0, single_shot=False, max_iters=None, delay=None, instantiate=False, attempt=False):
        assert (callable(fun))
        assert (isinstance(single_shot, bool))
        assert (isinstance(instantiate, bool))
        if max_iters:
            assert (isinstance(max_iters, int))

        if delay:
            assert (delay >= 0.0)
        else:
            assert (seconds >= 0.0)
            assert (minutes >= 0.0)
            assert (hours >= 0.0)
            delay = seconds + (minutes * 60.0) + (hours * 60.0 * 60.0)

        self.taskList.append({"function": fun,
                              "delay": float(delay),
                              "singleShot": single_shot,
                              "completed": False,
                              "remaining_iters": max_iters,
                              "instantiate": instantiate,
                              "lastRunTime": None,
                              "attempt": attempt})

    def run(self):
        self.start_time = time.time()
        for taskIndex in range(len(self.taskList)):
            self.taskList[taskIndex]['lastRunTime'] = self.start_time

        while self.taskList:
            for taskIndex in range(len(self.taskList)):
                task = self.taskList[taskIndex]
                if time.time() - task["lastRunTime"] >= task["delay"] or task['instantiate']:
                    self.taskList[taskIndex]["lastRunTime"] = time.time()
                    if task['attempt']:
                        try:
                            self.taskList[taskIndex]["function"]()
                        except KeyboardInterrupt:
                            sys.exit(0)
                        except:
                            traceback.print_exc()
                    else:
                        self.taskList[taskIndex]["function"]()

                    if task['remaining_iters'] is not None:
                        self.taskList[taskIndex]['remaining_iters'] -= 1
                    if task['singleShot'] or task['remaining_iters'] == 0:
                        self.taskList[taskIndex]["completed"] = True
                    if task['instantiate']:
                        self.taskList[taskIndex]["instantiate"] = False

            for taskIndex in reversed(range(len(self.taskList))):
                if self.taskList[taskIndex]["completed"]:
                    del self.taskList[taskIndex]

            if self.max_runtime and time.time() - self.start_time > self.max_runtime:
                print("Finished.")
                break

            time.sleep(0.0001)

if __name__ == "__main__":
    obj_class = NumberFactory(25)
    scheduler = TaskScheduler(obj=obj_class, max_runtime=25)
    assert (isinstance(scheduler.obj, NumberFactory))
    scheduler.add_task(scheduler.obj.increment, seconds=1)
    scheduler.add_task(scheduler.obj.decrement, seconds=2)
    scheduler.add_task(scheduler.obj.square, minutes=0.15, instantiate=True)
    scheduler.add_task(scheduler.obj.increment, seconds=0.2, max_iters=5)

    scheduler.run()