#!/usr/bin/env python3
import threading
from threading import Condition
def is_main_thread():
return isinstance(threading.current_thread(), threading._MainThread)
class MainThreadController(object):
def __init__(self):
if not is_main_thread():
raise Exception("A controller can only be created from the main thread")
self._main_wake_up = Condition()
self._main_wake_up.acquire()
self._obj = None
self._caller_wake_up = None
self._args = None
self._kwargs = None
self._return = None
self._quit = False
def invoke(self, obj, *args, **kwargs):
if is_main_thread():
return obj.__call__(*args, **kwargs)
released = False
self._main_wake_up.acquire()
try:
self._caller_wake_up = Condition()
with self._caller_wake_up:
self._obj = obj
self._args = args
self._kwargs = kwargs
# tell the main thread to wake up
self._main_wake_up.notify_all()
self._main_wake_up.release()
released = True
self._caller_wake_up.wait()
# tell the main thread that we received the result:
self._caller_wake_up.notify_all()
ret = self._return
return ret
finally:
self._obj = None
self._args = None
self._kwargs = None
self._caller_wake_up = None
self._return = None
if not released:
self._main_wake_up.release()
def quit(self):
self._main_wake_up.acquire()
try:
self._quit = True
self._main_wake_up.notify_all()
finally:
self._main_wake_up.release()
def run(self):
if not is_main_thread():
raise Exception("run can only be called from the main thread!")
from . import signals
def signal_handler(signal, frame):
self._quit = True
signals.add_sigint_handler(signal_handler)
while True:
try:
self._main_wake_up.wait(1.0)
except KeyboardInterrupt:
self._quit = True
if self._quit:
return
elif self._caller_wake_up is None:
# we timed out
continue
with self._caller_wake_up:
self._return = self._obj.__call__(*self._args, **self._kwargs)
self._caller_wake_up.notify_all()
# wait for the calling thread to confirm it received the result
while not self._caller_wake_up.wait(1.0):
if self._quit:
return
class MainThreadWrapper(object):
def __init__(self, mainobj, controller):
self._main = mainobj
self._controller = controller
def __call__(self, *args, **kwargs):
ret = self._controller.invoke(self._main, *args, **kwargs)
if id(self._main) == id(ret):
return MainThreadWrapper(ret, self._controller)
else:
return ret
def __getattribute__(self, name):
if name == '_main' or name == '_controller':
return object.__getattribute__(self, name)
elif isinstance(getattr(type(self._main), name), property):
return getattr(self._main, name)
else:
return MainThreadWrapper(getattr(self._main, name), self._controller)
if __name__ == '__main__':
class MainThreadOnlyClass(object):
def do_stuff(self):
if not is_main_thread():
raise Exception("ERROR!")
return 1337
main_thread_only = MainThreadOnlyClass()
controller = MainThreadController()
def dostuff(mtoc):
print(mtoc.do_stuff())
from threading import Thread
thread = Thread(target = dostuff, args = (MainThreadWrapper(main_thread_only, controller),))
thread.start()
controller.run()
thread.join()
