    from time import time, sleep
    from threading import Event, Thread

    class TaskHandler:
        """
        While the Task class only knows what task to perform with the run()-method,
        the TaskHandler has all the knowledge about the periodicity of the task.
        Instances of this class are managed by the Scheduler in the
        scheduled, running and onDemand dictionaries.
        """

        ## Init ##

        def __init__(self, scheduler, start, period, task, name):
            self._scheduler = scheduler
            self._task = task
            self._name = name
            self._thread = None
            self._isRunning = 0
            self._suspend = 0
            self._lastTime = None
            self._startTime = start
            self._registerTime = time()
            self._reregister = 1
            self._rerun = 0
            self._period = abs(period)

        ## Scheduling ##

        def reset(self, start, period, task, reregister):
            self._startTime = start
            self._period = abs(period)
            self._task = task
            self._reregister = reregister

        def runTask(self):
            """
            Runs this task in a background thread.
            """
            if self._suspend:
                self._scheduler.notifyCompletion(self)
                return
            self._rerun = 0
            self._thread = Thread(None, self._task._run, self.name(), (self,))
            self._isRunning = 1
            self._thread.start()

        def reschedule(self):
            """
            Method to determine whether this task should be rescheduled. Increments the
            startTime and returns true if this is a periodically executed task.
            """
            if self._period == 0:
                return 0
            else:
                if self._lastTime - self._startTime > self._period:  #if the time taken to run the task exceeds the period
                    self._startTime = self._lastTime + self._period
                else:
                    self._startTime = self._startTime + self._period
                return 1

        def notifyCompletion(self):
            self._isRunning = 0
            self._lastTime = time()
            self._scheduler.notifyCompletion(self)

        ## Attributes ##

        def isRunning(self):
            return self._isRunning

        def runAgain(self):
            """
            This method lets the Scheduler check to see whether this task should be
            re-run when it terminates
            """
            return self._rerun

        def isOnDemand(self):
            """
            Returns true if this task is not scheduled for periodic execution.
            """
            return self._period == 1

        def runOnCompletion(self):
            """
            Method to request that this task be re-run after its current completion.
            Intended for on-demand tasks that are requested by the Scheduler while
            they are already running.
            """
            self._rerun = 1

        def unregister(self):
            """
            Method to request that this task not be kept after its current completion.
            Used to remove a task from the scheduler
            """
            self._reregister = 0
            self._rerun = 0

        def disable(self):
            """
            Method to disable future invocations of this task.
            """
            self._suspend = 1

        def enable(self):
            """
            Method to enable future invocations of this task.
            """
            self._suspend = 0

        def period(self):
            """
            Returns the period of this task.
            """
            return self._period

        def setPeriod(self, period):
            """
            Mmethod to change the period for this task.
            """
            self._period = period

        def stop(self):
            self._isRunning = 0

        def name(self):
            return self._name

        def startTime(self, newTime=None):
            if newTime:
                self._startTime = newTime
            return self._startTime