Experiment: Interruptible AHK commands

This essentially reverts the following commits:

- 55a95e0
- b4a2ae5
- a6b013e
- a478d4f

The trick to interruptible AHK commands is setting the timer to check
for signals *before* calling the main Python script. This makes sense,
because the only time the AHK timers tick during the main Python code,
is when the Python code calls a blocking AHK command.

However, the biggest downside of this approach is that the signal that
was detected by the timer cannot interrupt the blocking AHK command that
allowed this timer to execute. Thus, there's no way to raise
KeyboardInterrupt during the AHKCall.

Author: Perlence

ahkpy/Python.ahk

@@ -109,14 +109,14 @@ Main() {
     handleCtrlEventCB := RegisterCallback("HandleCtrlEvent", "Fast")
     DllCall("SetConsoleCtrlHandler", "Ptr", handleCtrlEventCB, "Int", true)
 
+    SetTimer, CheckSignals, 100
+
     result := PyObject_CallObject(mainFunc, NULL)
     Py_DecRef(mainFunc)
     if (result == NULL) {
         PrintErrorOrExit()
     }
     Py_DecRef(result)
-
-    SetTimer, CheckSignals, 100
 }
 
 PackBuiltinModule() {

ahkpy/clipboard.py

@@ -2,7 +2,7 @@
 import functools
 from typing import Callable
 
-from .flow import ahk_call, _wait_for, _wrap_callback
+from .flow import ahk_call, _wrap_callback
 
 __all__ = [
     "ClipboardHandler",
@@ -36,13 +36,18 @@ def wait_clipboard(timeout: float = None) -> str:
 
     If there is no text in the clipboard after *timeout* seconds, then an empty
     string will be returned. If *timeout* is not specified or ``None``, there is
-    no limit to the wait time.
+    no limit to the wait time. Specifying 0 is the same as specifying 0.5.
 
     :command: `ClipWait
        <https://www.autohotkey.com/docs/commands/ClipWait.htm>`_
     """
     # TODO: Implement WaitForAnyData argument.
-    return _wait_for(timeout, get_clipboard) or ""
+    if timeout is not None:
+        timeout = float(timeout)
+    ok = ahk_call("ClipWait", timeout)
+    if not ok:
+        return ""
+    return get_clipboard()
 
 
 def on_clipboard_change(func: Callable = None, *args, prepend_handler=False):

ahkpy/flow.py

@@ -4,7 +4,6 @@
 import queue
 import sys
 import threading
-import time
 
 import _ahk
 
@@ -55,31 +54,12 @@ def sleep(secs):
     """
     if not isinstance(secs, (int, float)):
         raise TypeError(f"a number is required (got type {secs.__class__.__name__})")
-    _wait_for(secs, None)
-
-
-def _wait_for(secs, check_fn):
-    if secs is None:
-        secs = float("inf")
-
     if secs < 0:
         raise ValueError("sleep length must be non-negative")
-    elif secs <= _poll_interval:
-        time.sleep(secs)
-        poll()
-        return check_fn and check_fn()
+    elif secs == 0:
+        ahk_call("Sleep", 0)
     else:
-        stop = time.perf_counter() + secs
-        while time.perf_counter() < stop:
-            time.sleep(_poll_interval)
-            poll()
-            result = check_fn and check_fn()
-            if result:
-                return result
-
-
-# The interval between AHK message queue polls during the blocking operations.
-_poll_interval = 0.01
+        ahk_call("Sleep", int(secs * 1000))
 
 
 def poll():
@@ -150,6 +130,10 @@ def output_debug(*objects, sep=" "):
     ctypes.windll.kernel32.OutputDebugStringW(debug_str)
 
 
+# The interval between AHK message queue polls during the blocking operations.
+_poll_interval = 0.01
+
+
 def coop(func, *args, **kwargs):
     """Run the given function in a new thread and make it cooperate with AHK's
     event loop.

ahkpy/key_state.py

@@ -1,6 +1,4 @@
-import functools
-
-from .flow import ahk_call, _wait_for
+from .flow import ahk_call
 
 __all__ = [
     "get_caps_lock_state",
@@ -98,22 +96,34 @@ def wait_key_pressed(key_name, timeout: float = None) -> bool:
     after *timeout* seconds, then ``False`` will be returned. If *timeout* is
     not specified or ``None``, there is no limit to the wait time.
     """
-    return _wait_for(timeout, functools.partial(is_key_pressed, key_name)) or False
+    return _key_wait(key_name, down=True, logical=False, timeout=timeout)
 
 
 def wait_key_released(key_name, timeout: float = None) -> bool:
     """Wait for a key or mouse/joystick button to be released physically."""
-    return _wait_for(timeout, lambda: not is_key_pressed(key_name)) or False
+    return _key_wait(key_name, down=False, logical=False, timeout=timeout)
 
 
 def wait_key_pressed_logical(key_name, timeout: float = None) -> bool:
     """Wait for a key or mouse/joystick button logical state to be pressed."""
-    return _wait_for(timeout, functools.partial(is_key_pressed_logical, key_name)) or False
+    return _key_wait(key_name, down=True, logical=True, timeout=timeout)
 
 
 def wait_key_released_logical(key_name, timeout: float = None) -> bool:
     """Wait for a key or mouse/joystick button logical state to be released."""
-    return _wait_for(timeout, lambda: not is_key_pressed_logical(key_name)) or False
+    return _key_wait(key_name, down=False, logical=True, timeout=timeout)
+
+
+def _key_wait(key_name, down=False, logical=False, timeout=None) -> bool:
+    options = []
+    if down:
+        options.append("D")
+    if logical:
+        options.append("L")
+    if timeout is not None:
+        options.append(f"T{timeout}")
+    ok = ahk_call("KeyWait", str(key_name), "".join(options))
+    return bool(ok)
 
 
 def get_key_name(key_name: str) -> str:

ahkpy/window.py

@@ -9,7 +9,7 @@
 from . import colors
 from . import sending
 from .exceptions import Error
-from .flow import ahk_call, global_ahk_lock, _wait_for
+from .flow import ahk_call, global_ahk_lock
 from .hotkey_context import HotkeyContext
 from .settings import get_settings, optional_ms
 from .unset import UNSET, UnsetType
@@ -280,7 +280,7 @@ def wait(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET,
            <https://www.autohotkey.com/docs/commands/WinWait.htm>`_
         """
         self = self._filter(title, class_name, id, pid, exe, text, match)
-        return _wait_for(timeout, self.exist) or Window(None)
+        return self._wait("WinWait", timeout)
 
     def wait_active(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET, text=UNSET, match=None,
                     timeout=None):
@@ -297,7 +297,7 @@ def wait_active(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe
         query = self._query()
         if query == ("", "", "", ""):
             self = dc.replace(self, title="A")
-        return _wait_for(timeout, self.get_active) or Window(None)
+        return self._wait("WinWaitActive", timeout)
 
     def wait_inactive(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET, text=UNSET, match=None,
                       timeout=None) -> bool:
@@ -316,7 +316,7 @@ def wait_inactive(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, e
            <https://www.autohotkey.com/docs/commands/WinWaitActive.htm>`_
         """
         self = self._filter(title, class_name, id, pid, exe, text, match)
-        return _wait_for(timeout, lambda: not self.get_active()) or False
+        return self._wait_close("WinWaitNotActive", timeout)
 
     def wait_close(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET, text=UNSET, match=None,
                    timeout=None):
@@ -335,9 +335,22 @@ def wait_close(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=
            <https://www.autohotkey.com/docs/commands/WinWaitClose.htm>`_
         """
         self = self._filter(title, class_name, id, pid, exe, text, match)
-        # WinWaitClose doesn't set Last Found Window, return False if the wait
-        # was timed out.
-        return _wait_for(timeout, lambda: not self.exist()) or False
+        return self._wait_close("WinWaitClose", timeout)
+
+    def _wait(self, cmd, timeout):
+        win_id = self._call(cmd, *self._include(), timeout, *self._exclude(), set_delay=True)
+        if not win_id:
+            return Window(None)
+        return Window(win_id)
+
+    def _wait_close(self, cmd, timeout):
+        # WinWaitClose and WinWaitNotActive don't set the Last Found Window,
+        # return False if the wait was timed out.
+        ok = self._call(cmd, *self._include(), timeout, *self._exclude(), set_delay=True)
+        if ok is None:
+            # There are no matching windows, and that's what we are waiting for.
+            return True
+        return bool(ok)
 
     def close_all(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET, text=UNSET, match=None,
                   timeout=None):
@@ -455,9 +468,9 @@ def _group_action(self, cmd, timeout=UNSET):
         query_hash_str = str(query_hash).replace("-", "m")  # AHK doesn't allow "-" in group names
         label = ""
         self._call("GroupAdd", query_hash_str, *self._include(), label, *self._exclude())
-        self._call(cmd, f"ahk_group {query_hash_str}", "", "", set_delay=True)
+        self._call(cmd, f"ahk_group {query_hash_str}", "", timeout or "", set_delay=True)
         if timeout is not UNSET:
-            return self.wait_close(timeout=timeout)
+            return not self.exist()
 
     def window_context(self, title=UNSET, *, class_name=UNSET, id=UNSET, pid=UNSET, exe=UNSET, text=UNSET, match=None):
         """window_context(title: str = UNSET, **criteria) -> ahkpy.HotkeyContext
@@ -1961,14 +1974,11 @@ def wait_status_bar(self, bar_text="", *,
         :command: `StatusBarWait
            <https://www.autohotkey.com/docs/commands/StatusBarWait.htm>`_
         """
-        # TODO: StatusBarWait is blocking and is not interruptable. However, it
-        # is usually more efficient to use StatusBarWait rather than calling
-        # StatusBarGetText in a loop.
         try:
             ok = self._call(
                 "StatusBarWait",
                 bar_text,
-                timeout,
+                timeout if timeout is not None else "",
                 part + 1,
                 *self._include(),
                 interval * 1000,