Programador sched.scheduler de forma asincrono

[camontuyu]

Hola,*
*estoy intentando crear una clase que lance una función o un método 
determinado después de que transcurran una serie de segundos. Para ello 
mirando la documentación de *Python* he encontrado una clase para esta 
función, *sched.scheduler*.

El problema es que se interrumpe la ejecución del programa cuando lanzo 
el scheduler. Lo solucioné creando un hilo que controle esta clase.

Hasta ahora todo bien, el problema es que me gustaría darle más 
funcionalidad. Cuando me interese me gustaría cancelar la ejecución de 
todo el programador despues de haberlo lanzado.

Aqui posteo el código desarrollado, haber si encontrais algún error y 
podeís orientarme un poco.

MODULO programador.py

import     threading
import     sched, time

class Programador(threading.Thread):
    """ se encarga de lanzar un funcion en un determinado tiempo """
   
    def __init__(self):
        threading.Thread.__init__(self)
        self.__planificador = sched.scheduler(time.time, self.esperar)
        self.__fin = False
       
    def programar(self, funcion, tiempo, parametros=None):
        """
            inicializa el programador, la funcion será lanzada en el tiempo
            indicado (tiempo en segundos) y con los parametros
        """
        if parametros is None:
            self.__planificador.enter(tiempo, 1, funcion, ())
        else:
            self.__planificador.enter(tiempo, 1, funcion, (parametros,))
   
    def run(self):
        """ inicializa la hebra y lanza el planificador """
        self.__fin = False
        self.__planificador.run()

    def cancelar(self):
        self.__fin = True

    def esperar(self, t):
        """ funcion que espera t segundos comprobando durante esos t 
segundos
        si hemos cancelado la espera """
        if t == 0:
            print "llamado con cero"
           
        for i in xrange(int(t)):
            time.sleep(1)
            if self.__fin:
                self.__planificador = None
                print "rompiendo " + `self.__fin`
                break

Ahora para probar su funcionamiento he creado ....

import time
from misc.programador import Programador

def pintar(cad):
    print "Estoy pintando %s" % cad

if (__name__ == '__main__'):
    p = Programador()   
    p.programar(pintar, 10, 'he sido lanzada')
    p.start()
   
    print "esperando 3 seg, dentro de 10 se lanza funcion"
    time.sleep(3)   
    print "voy a cancelar..."
    p.cancelar()

El resultado de la ejecución es...

esperando 3 seg, dentro de 10 se lanza funcion
[3 segundos]
voy a cancelar...
[7 segundos]
Estoy pintando he sido lanzada

Como podeis observar después de llamar al método cancelar debería 
interrumpir el lanzamiento de la función pintar. Pero no lo hace :(

Hay alguna forma de matar la hebra o de conseguir que funcione (incluso 
de otra forma)

Perdonar por lo estenso del correo.

Un saludo y muchas gracias.