added call_nosync

serwy · serwy · commit 654b569d5c20 · 2022-06-25T13:49:36.000-05:00
diff --git a/README.md b/README.md
@@ -122,6 +122,10 @@ use `root` as the master.
     - same as `.patch()`
 - `tkthread.call(func, *args, **kw)`
     - call `func` on the main thread, with arguments and keyword arguments.
+    - waits for return value (or raises error)
+- `tkthread.call_nosync(func, *args, **kw)`
+    - call `func` on the main thread, with arguments and keyword arguments.
+    - returns immediately, ignore return `func` return or error.
 - `@tkthread.called_on_main`
     - decorator to dispatch the function call on the main thread from the calling thread.
 - `@tkthread.main()`
diff --git a/tests/test_tkthread.py b/tests/test_tkthread.py
@@ -340,8 +340,57 @@ def func():
             self.root.update()
 
         self.assertIs(d['called'], True)
+        @tkthread.main()
+        def _():
+            d['called'] = True
+
+        t = threading.current_thread()
+
         self.assertIs(d['thread'], t)
 
+    def test_main_nosync(self):
+        d = dict()
+
+        main_thread = threading.current_thread()
+
+        @thread_start()
+        def tstart_nosync():
+
+            @tkthread.main(sync=False)
+            def func():
+                d['nosync'] = threading.current_thread()
+
+        @call_until(4.0)
+        def alive():
+            return tstart_nosync.is_alive()
+
+        self.assertFalse(tstart_nosync.is_alive())
+        self.assertFalse(alive)
+        self.assertFalse('nosync' in d)
+
+        @thread_start()
+        def tstart():
+            @tkthread.main(sync=True)
+            def func():
+                d['sync'] = threading.current_thread()
+
+        @call_until(4.0)
+        def has_thread():
+            self.root.update()
+            return 'sync' not in d
+
+
+        @call_until(4.0)
+        def tstart_timeout():
+            self.root.update()
+            return tstart.is_alive()
+
+        self.assertTrue('nosync' in d)
+        self.assertTrue('sync' in d)
+
+        self.assertIs(d['sync'], main_thread)
+        self.assertIs(d['nosync'], main_thread)
+
     def test_current(self):
         d = dict(called=False, thread=False)
         @tkthread.current()
diff --git a/tkthread/__init__.py b/tkthread/__init__.py
@@ -103,11 +103,16 @@ def run(func):
 
 from ._version import __version__
 from ._willdispatch import (
-    tkinstall, main, current, call, called_on_main
+    tkinstall, main, current,
+    call, call_nosync,
+    called_on_main
     )
 
-__all__ = ['TkThread', 'tk', '__version__',
-           'tkinstall', 'main', 'current', 'call', 'patch']
+__all__ = [
+    'TkThread', 'tk', '__version__',
+    'tkinstall', 'patch', 'main', 'current',
+    'call', 'call_nosync',
+    ]
 
 patch = tkinstall  # Issue #4
 
diff --git a/tkthread/_willdispatch.py b/tkthread/_willdispatch.py
@@ -231,8 +231,12 @@ def sync_wrapped(_func=func, _ev=ev):
                 ev.wait()
 
             else:
-                _ensure_after_idle(w, func)
-
+                th = threading.Thread(
+                    target=_ensure_after_idle,
+                    args=(w, func),
+                    name='tkthread.main')
+                th.daemon = True
+                th.start()
 
         return func
     return wrapped
@@ -275,6 +279,11 @@ def call(func, *args, **kwargs):
     return _callsync(True, func, args, kwargs)
 
 
+def call_nosync(func, *args, **kwargs):
+    """Enqueue the function for calling on the main thread, immediately return."""
+    return _callsync(False, func, args, kwargs)
+
+
 class called_on_main:
     """Decorator to cause function call to execute on the main thread.
 
