import threading
import time


class ThreadClass:

    class FuncObject:
        def __init__(self):
            self.clear()

        def clear(self):
            self.func = None
            self.args = []
            self.kwargs = {}
            self.changed = False

    def __init__(self, cls):
        self.enable = True
        self._funcObject = self.FuncObject()
        self.event = threading.Event()
        self.event.clear()
        thread = threading.Thread(target=self._ret_func, args=(cls,))
        thread.start()

    def set_func(self, func, args=[], kwargs={}):
        self._funcObject.func = func
        self._funcObject.args = args
        self._funcObject.kwargs = kwargs
        self._funcObject.changed = True
        self.event.set()

    def _ret_func(self, cls):
        obj = cls()
        while(self.enable):

            self.event.wait(10)
            if self.event.is_set():
                self.event.clear()

            if self.enable == False:
                break

            if self._funcObject.changed:
                if self._funcObject.func in cls.__dict__:
                    if self._funcObject.args:
                        cls.__dict__[self._funcObject.func](obj, *self._funcObject.args)
                    elif self._funcObject.kwargs:
                        cls.__dict__[self._funcObject.func](obj, **self._funcObject.kwargs)
                    else:
                        cls.__dict__[self._funcObject.func](obj)

                self._funcObject.clear()



    def stop(self):
        self.enable = False
        self.event.set()

if __name__ == '__main__':

    class TestClass:
        def a_func(self):
            print "a_func"

        def b_func(self, data):
            print "b_func", data


    a = ThreadClass(TestClass)
    b = ThreadClass(TestClass)
    for i in xrange(5):
        a.set_func("a_func")
        b.set_func("a_func")
        time.sleep(0.1)
        a.set_func("b_func", ("args test a: %s"%i,))
        b.set_func("b_func", ("args test b",))
        time.sleep(0.1)
        a.set_func("b_func", kwargs={"data": "kwargs test a"})
        b.set_func("b_func", kwargs={"data": "kwargs test b"})
        time.sleep(0.1)
    a.stop()
    b.stop()

from Queue import Queue
from threading import Thread
from collections import Callable

class ThreadProxy(object):
    
    def __init__(self, obj):
        self.__obj = obj
        self.__requests = Queue()
        self.__worker = Thread(target=self.__run)
        self.__worker.start()
        
    def stop(self):
        self.__requests.put(None)
        self.__worker.join()
        
    def __run(self):
        while True:
            req = self.__requests.get()
            if req is None: 
                self.__requests.task_done()
                break
            func, args, kw = req
            func(*args, **kw)
            self.__requests.task_done()
            
    def __getattr__(self, func):
        attr = getattr(self.__obj, func)
        
        def _proxy(*args, **kw):
            self.__requests.put((attr, args, kw))
            
        if isinstance(attr, Callable):   
            return _proxy
        else:
            return attr

if __name__ == '__main__':
    
    import time

    class TestClass:
        
        def __init__(self):
            self.data = "data"
        
        def a_func(self):
            print "a_func"

        def b_func(self, data):
            print "b_func", data

    a = ThreadProxy(TestClass())
    b = ThreadProxy(TestClass())

    for i in xrange(5):
        a.a_func()
        b.a_func()
        time.sleep(0.1)
        a.b_func("args test a: %s" % i)
        b.b_func("args test b")
        time.sleep(0.1)
        a.b_func(data="kwargs test a")
        b.b_func(data="kwargs test b")
        time.sleep(0.1)
        print a.data
        
    a.stop()
    b.stop()

from Queue import Queue
from threading import Thread
 
class ThreadProxyClass(object):
    def __init__(self, obj):
        self.__obj = obj
        self.__requests = Queue()
        self.__worker = Thread(target=self.__run)
        self.__worker.daemon = True # argh...
        self.__worker.start()
    def stop(self):
        self.__requests.put(None)
        self.__worker.join()
    def __run(self):
        while True:
            req = self.__requests.get()
            try:
                if req is None: break
                func, args, kw = req
                func(*args, **kw)
            except:
                pass
            finally:
                self.__requests.task_done()
    def __getattr__(self, key):
        attr = getattr(self.__obj, key)
        if not callable(attr): return attr
        def _proxy(*args, **kw):
            self.__requests.put((attr, args, kw))
        return _proxy
    def __setattr__(self, key, val):
        if key.startswith('_' + self.__class__.__name__):
            return object.__setattr__(self, key, val)
        return setattr(self.__obj, key, val)
    def __delattr__(self, key):
        if key.startswith('_' + self.__class__.__name__):
            return object.__delattr__(self, key)
        return delattr(self.__obj, key)
 
if __name__ == '__main__':
    import time
    
    class TestClass:
        def a_func(self):
            print "a_func"
        
        def b_func(self, data):
            print "b_func", data
    
    a = ThreadProxyClass(TestClass())
    b = ThreadProxyClass(TestClass())
    
    for i in xrange(5):
        a.a_func()
        b.a_func()
        time.sleep(0.1)
        a.b_func("args test a: %s" % i)
        b.b_func("args test b")
        time.sleep(0.1)
        a.b_func(data="kwargs test a")
        b.b_func(data="kwargs test b")
        time.sleep(0.1)
    a.stop()
    b.stop()

class ThreadProxy(object):
    def __init__(self):
        self._requests = Queue()
        self._worker = Thread(target=self._run)
        self._worker.daemon = True # argh...
        self._worker.start()

    def run(self, fun, *args, **kw):
        self._requests.put((fun, args, kw))

    def stop(self):
        self._requests.put(None)
        self._worker.join()

    def _run(self):
        while True:
            req = self._requests.get()
            if req:
                func, args, kwargs = req
                func(*args, **kwargs)
            else:
                break

if __name__ == '__main__':
    ...
    testa = TestClass()
    a = ThreadProxy()
    a.run(testa.b_func, data="kwargs test a")