urkit 0.4.3__tar.gz → 0.4.5__tar.gz

{urkit-0.4.3 → urkit-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urkit
-Version: 0.4.3
+Version: 0.4.5
 Summary: Universal Robots e-Series control toolkit built on ur_rtde
 Author: URKit Contributors
 License: MIT

{urkit-0.4.3 → urkit-0.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "urkit"
-version = "0.4.3"
+version = "0.4.5"
 description = "Universal Robots e-Series control toolkit built on ur_rtde"
 readme = "README.md"
 license = {text = "MIT"}

{urkit-0.4.3 → urkit-0.4.5}/src/urkit/__init__.py

@@ -24,7 +24,7 @@ Quick start::
 
 from __future__ import annotations
 
-__version__ = "0.4.3"
+__version__ = "0.4.5"
 
 
 from urkit.exceptions import (

{urkit-0.4.3 → urkit-0.4.5}/src/urkit/cli/teach.py

@@ -26,7 +26,9 @@ import yaml
 from urkit.cli.colors import blue, cyan, dim, green, red, yellow
 from urkit.cli.terminal import (
     RawTerminal,
+    input_active,
     read_burst,
+    start_interrupt_watcher,
     wait_input,
     warn_if_windows,
 )
@@ -442,13 +444,11 @@ def _draw_help() -> None:
 
 # Raw terminal shared by the main loop, the SIGINT handler, and the
 # exit path. All terminal setup goes through the cross-platform shim.
-# echo=True matches the pre-shim cbreak behavior of the main loop
-# (echo on, canonical off); submenus and prompts use echo=False.
-_raw_terminal = RawTerminal(echo=True)
+_raw_terminal = RawTerminal()
 
 
 def _configure_terminal() -> None:
-    """Enter raw terminal mode (no canonical, echo on)."""
+    """Enter raw terminal mode (no canonical, no echo)."""
     _raw_terminal.enable()
 
 
@@ -477,6 +477,7 @@ def _read_input(prompt: str, max_len: int = 30) -> str | None:
     sys.stdout.flush()
 
     name = ""
+    input_active.set()
     try:
         while True:
             if not wait_input(0.1):
@@ -513,6 +514,7 @@ def _read_input(prompt: str, max_len: int = 30) -> str | None:
                 break
     finally:
         raw.disable()
+        input_active.clear()
 
     sys.stdout.write("\r\033[K\n")
     sys.stdout.flush()
@@ -626,7 +628,11 @@ def _filter_select_points(
 
             # Wait for input, then read the full burst (e.g. the
             # 3-byte \x1b[A arrow-key sequence) in one go.
-            raw_bytes = read_burst(0.1)
+            input_active.set()
+            try:
+                raw_bytes = read_burst(0.1)
+            finally:
+                input_active.clear()
             if not raw_bytes:
                 if _cli_monitor and _cli_monitor.fault_detected:
                     raise URKitConnectionError(
@@ -741,11 +747,15 @@ def _submenu_goto_point(
                 robot, name, mode_label, start_pose, target_pose, is_cartesian, max_progress
             )
             max_progress = pct
-            if wait_input(0.05):
-                key = read_burst(0.0).decode("ascii", errors="replace")
-                if " " in key:  # Space to cancel
-                    cancelled = True
-                    break
+            input_active.set()
+            try:
+                if wait_input(0.05):
+                    key = read_burst(0.0).decode("ascii", errors="replace")
+                    if " " in key:  # Space to cancel
+                        cancelled = True
+                        break
+            finally:
+                input_active.clear()
 
         # Clear moving screen
         sys.stdout.write("\033[2J\033[1;1H")
@@ -905,7 +915,11 @@ def _submenu_orient_tcp(
                 sys.stdout.flush()
                 needs_redraw = False
 
-            raw_bytes = read_burst(0.1)
+            input_active.set()
+            try:
+                raw_bytes = read_burst(0.1)
+            finally:
+                input_active.clear()
             if not raw_bytes:
                 if _cli_monitor and _cli_monitor.fault_detected:
                     raise URKitConnectionError(
@@ -1024,7 +1038,11 @@ def _submenu_freedrive_axes(
                 sys.stdout.flush()
                 needs_redraw = False
 
-            raw_bytes = read_burst(0.1)
+            input_active.set()
+            try:
+                raw_bytes = read_burst(0.1)
+            finally:
+                input_active.clear()
             if not raw_bytes:
                 continue
             text = raw_bytes.decode("ascii", errors="replace")
@@ -1185,12 +1203,12 @@ def _teach_pendant(
         print("Error: stdin is not a terminal. Run from an interactive shell.")
         sys.exit(1)
 
-    # SIGINT handler: restore terminal and exit when Ctrl+C pressed.
-    # On Unix, raw mode keeps ISIG enabled, so Ctrl+C generates SIGINT.
-    # On Windows, Ctrl+C arrives as a raw 0x03 byte instead (handled by
-    # the main loop's exit key path). os._exit() works even when blocked
+    # Best-effort robot stop and terminal restore, then exit.
+    # Runs from the SIGINT handler (Unix Ctrl+C) and from the
+    # interrupt watcher (Windows Ctrl+C / fault while the main thread
+    # is blocked in a robot call). os._exit() works even when blocked
     # in C library code.
-    def _sigint_handler(signum: int, frame: object) -> None:
+    def _interrupt_exit(reason: str) -> None:
         try:
             if state["freedrive"]:
                 robot.disable_freedrive()
@@ -1209,9 +1227,16 @@ def _teach_pendant(
             _restore_terminal()
         except Exception:
             pass
-        sys.stderr.write("\nInterrupted.\n")
+        sys.stderr.write(f"\n{reason}\n")
         os._exit(0)
 
+    # SIGINT handler: restore terminal and exit when Ctrl+C pressed.
+    # On Unix, raw mode keeps ISIG enabled, so Ctrl+C generates SIGINT.
+    # On Windows, Ctrl+C arrives as a raw 0x03 byte instead (handled by
+    # the main loop's exit key path and the interrupt watcher).
+    def _sigint_handler(signum: int, frame: object) -> None:
+        _interrupt_exit("Interrupted.")
+
     signal.signal(signal.SIGINT, _sigint_handler)
 
     # Connection watchdog: detects faults and interrupts blocking calls.
@@ -1227,6 +1252,21 @@ def _teach_pendant(
     global _cli_monitor
     _cli_monitor = monitor  # used by _read_input and _filter_select_points
 
+    # Windows escape hatch: no SIGINT delivery and no SIGALRM, so while
+    # the main thread is blocked in a long RTDE call (e.g. a move while
+    # a key is held) neither Ctrl+C (a console byte) nor a detected
+    # fault can reach it. The watcher fires the same cleanup and exit.
+    def _watcher_fault_reason() -> str | None:
+        if monitor.fault_detected:
+            return (
+                f"Robot fault detected: "
+                f"{monitor._reason or 'RTDE connection lost'}. "
+                "RTDE connection lost."
+            )
+        return None
+
+    start_interrupt_watcher(_interrupt_exit, _watcher_fault_reason)
+
     try:
         try:
             _configure_terminal()
@@ -1241,33 +1281,40 @@ def _teach_pendant(
                 command_handled = False
 
                 # --- Wait for a key ---
-                while True:
-                    if wait_input(0.05):
-                        break
-
-                    # Periodic refresh while in freedrive — robot may be moving by hand
-                    if state["freedrive"]:
-                        now = time.monotonic()
-                        if now - last_refresh >= _FREEDRIVE_REFRESH_S:
-                            last_refresh = now
-                            _draw_screen(robot, state, messages, expert_mode)
-
-                    # Check for fault detected by watchdog thread
-                    if monitor.fault_detected:
-                        raise URKitConnectionError(
-                            f"Robot fault detected: {monitor._reason or 'RTDE connection lost'}. "
-                            "RTDE connection lost."
-                        )
+                # input_active tells the Windows interrupt watcher to
+                # stay out of the console queue while we read.
+                input_active.set()
+                try:
+                    while True:
+                        if wait_input(0.05):
+                            break
+
+                        # Periodic refresh while in freedrive — robot may be moving by hand
+                        if state["freedrive"]:
+                            now = time.monotonic()
+                            if now - last_refresh >= _FREEDRIVE_REFRESH_S:
+                                last_refresh = now
+                                _draw_screen(robot, state, messages, expert_mode)
+
+                        # Check for fault detected by watchdog thread
+                        if monitor.fault_detected:
+                            raise URKitConnectionError(
+                                f"Robot fault detected: {monitor._reason or 'RTDE connection lost'}. "
+                                "RTDE connection lost."
+                            )
 
-                # --- Read key, draining buffered repeats ---
-                # When a key is held, the terminal auto-repeats it into the
-                # input buffer.  Reading only one character leaves stale repeats
-                # behind — when the user switches from one movement key to
-                # another, the last buffered copy of the old key fires one final
-                # move in the wrong direction before the new key is read.
-                # Fix: drain all immediately available bytes
-                # (non-blocking) and use the last one.
-                key_text = read_burst(0.0).decode("ascii", errors="replace")
+                    # --- Read key, draining buffered repeats ---
+                    # When a key is held, the terminal auto-repeats it into the
+                    # input buffer.  Reading only one character leaves stale
+                    # repeats behind — when the user switches from one
+                    # movement key to another, the last buffered copy of the
+                    # old key fires one final move in the wrong direction
+                    # before the new key is read.
+                    # Fix: drain all immediately available bytes
+                    # (non-blocking) and use the last one.
+                    key_text = read_burst(0.0).decode("ascii", errors="replace")
+                finally:
+                    input_active.clear()
                 key = key_text[-1].lower() if key_text else ""
                 if not key:
                     continue

{urkit-0.4.3 → urkit-0.4.5}/src/urkit/cli/terminal.py

@@ -9,8 +9,8 @@ The CLIs need three things from the platform:
 3. On Windows only: ANSI escape processing on stdout so colors and
    cursor codes render.
 
-Unix backend: termios + tty + select, exactly the syscalls the CLIs
-used to issue directly.
+Unix backend: termios + select, the same syscalls the CLIs used to
+issue directly.
 
 Windows backend: msvcrt with console input mode changed via kernel32.
 The console does not emit ANSI sequences for special keys, so the
@@ -30,15 +30,15 @@ from __future__ import annotations
 import ctypes
 import os
 import sys
+import threading
 import time
-from typing import Any
+from typing import Any, Callable
 
 if sys.platform == "win32":
     import msvcrt
 else:
     import select
     import termios
-    import tty
 
 if sys.platform == "win32":
     # CDLL is used instead of WinDLL because ctypes.WinDLL is only
@@ -78,18 +78,35 @@ if sys.platform == "win32":
         0x53: "\x1b[3~",  # Delete
     }
 
+    _WIN_ERROR_TEXT = {
+        5: "access denied",
+        6: "invalid handle",
+        87: "invalid parameter",
+        1225: "session disconnected",
+    }
+
+    def _win_error_detail() -> str:
+        code = ctypes.get_last_error()
+        return f"Win32 error {code} ({_WIN_ERROR_TEXT.get(code, 'unknown')})"
+
     def _console_mode(handle: int) -> int:
         mode = ctypes.c_uint32()
         if not _kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
             raise OSError(
-                "GetConsoleMode failed (stdin is not a console). "
-                "Run from an interactive shell."
+                f"GetConsoleMode failed ({_win_error_detail()}). stdin is "
+                "not a usable console handle; run urkit from an "
+                "interactive shell such as cmd or PowerShell."
             )
         return mode.value
 
-    def _set_console_mode(handle: int, mode: int) -> None:
+    def _set_console_mode(handle: int, mode: int, context: str) -> None:
         if not _kernel32.SetConsoleMode(handle, mode):
-            raise OSError("SetConsoleMode failed")
+            raise OSError(
+                f"SetConsoleMode failed while {context} "
+                f"({_win_error_detail()}, requested mode "
+                f"0x{mode:08x}). The Windows console refused the "
+                "terminal mode change."
+            )
 
     def _enable_ansi_output() -> None:
         """Enable ANSI escape processing on stdout.
@@ -102,12 +119,82 @@ if sys.platform == "win32":
             handle = _kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
             mode = _console_mode(handle)
             _set_console_mode(
-                handle, mode | _ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                handle,
+                mode | _ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+                "enabling ANSI output",
             )
         except OSError:
             pass
 
 
+input_active = threading.Event()
+"""Set while CLI code is actively reading stdin (input-wait loops, text
+prompts, menus). The Windows interrupt watcher stays out of the console
+input queue while this is set, so it can never steal a keystroke from
+the main reader. Callers set it around their read sections and clear it
+afterwards."""
+
+
+def start_interrupt_watcher(
+    on_fire: Callable[[str], None],
+    fault_reason: Callable[[], str | None],
+) -> threading.Thread | None:
+    """Start the Windows-only interrupt watcher. Returns None elsewhere.
+
+    On Windows, while the main thread is blocked in a long RTDE call
+    (not reading input) nothing can interrupt it: Ctrl+C is a raw
+    console byte that only the input loops read, and there is no
+    SIGALRM. This daemon thread covers that gap. It polls, only while
+    input_active is clear:
+
+    - fault_reason() for a connection/robot fault
+    - the console for a Ctrl+C (0x03) byte; any other byte is pushed
+      back with ungetch() so the main reader still sees it, and the
+      watcher backs off to avoid interfering with resumed input
+
+    When either fires it calls on_fire(reason) exactly once; the
+    caller should clean up (stop robot, restore terminal) and exit.
+    """
+    if sys.platform != "win32":
+        return None
+
+    # Only reachable on Windows (guard above), so this never runs on
+    # Linux. Local import because mypy prunes the top-level platform
+    # guard and cannot see the module inside this closure.
+    import msvcrt
+
+    def _run() -> None:
+        backoff = 0.0
+        while True:
+            if backoff > 0:
+                time.sleep(backoff)
+                backoff = 0.0
+            if input_active.is_set():
+                time.sleep(0.05)
+                continue
+            reason = fault_reason()
+            if reason is not None:
+                on_fire(reason)
+                return
+            if not msvcrt.kbhit():
+                time.sleep(0.05)
+                continue
+            byte = msvcrt.getch()
+            if byte == b"\x03":
+                on_fire("Interrupted.")
+                return
+            # Not Ctrl+C: give the byte back and back off so the main
+            # reader (resuming from a blocking call) processes it.
+            msvcrt.ungetch(byte[0])
+            backoff = 0.2
+
+    watcher = threading.Thread(
+        target=_run, daemon=True, name="interrupt-watcher"
+    )
+    watcher.start()
+    return watcher
+
+
 def warn_if_windows() -> None:
     """Print a notice when the interactive CLI runs on Windows.
 
@@ -136,15 +223,7 @@ class RawTerminal:
         raw.disable()   # idempotent, safe to call multiple times
     """
 
-    def __init__(self, echo: bool = False) -> None:
-        """Args:
-            echo: Keep terminal echo enabled (cbreak semantics).
-                The main teach loop uses echo=True to match the
-                pre-shim behavior; menus and input prompts use the
-                default echo=False because they display characters
-                themselves.
-        """
-        self._echo = echo
+    def __init__(self) -> None:
         self._enabled = False
         self._old_settings: list[Any] | None = None
         self._old_mode: int | None = None
@@ -156,29 +235,37 @@ class RawTerminal:
             return
         if sys.platform == "win32":
             self._stdin_handle = _kernel32.GetStdHandle(_STD_INPUT_HANDLE)
+            if not self._stdin_handle:
+                raise OSError(
+                    "stdin is not attached to a Windows console; run "
+                    "urkit from an interactive shell such as cmd or "
+                    "PowerShell."
+                )
             self._old_mode = _console_mode(self._stdin_handle)
-            # Disable processed input and line input. Ctrl+C arrives
-            # as raw byte 0x03 (handled by the CLIs) instead of
-            # KeyboardInterrupt, which would skip terminal restore.
-            # Echo is kept only when echo=True.
-            mode = self._old_mode & ~(
-                _ENABLE_PROCESSED_INPUT | _ENABLE_LINE_INPUT
+            # Disable processed input, line input, and echo. Ctrl+C
+            # arrives as raw byte 0x03 (handled by the CLIs) instead
+            # of KeyboardInterrupt, which would skip terminal restore.
+            # Echo is always off: some consoles refuse raw mode with
+            # echo still enabled, and the CLIs render input themselves.
+            _set_console_mode(
+                self._stdin_handle,
+                self._old_mode
+                & ~(
+                    _ENABLE_PROCESSED_INPUT
+                    | _ENABLE_LINE_INPUT
+                    | _ENABLE_ECHO_INPUT
+                ),
+                "entering raw mode",
             )
-            if not self._echo:
-                mode &= ~_ENABLE_ECHO_INPUT
-            _set_console_mode(self._stdin_handle, mode)
             _enable_ansi_output()
         else:
             self._old_settings = termios.tcgetattr(sys.stdin)
-            if self._echo:
-                # cbreak: no canonical mode, echo and signals stay on
-                tty.setcbreak(sys.stdin.fileno())
-            else:
-                # No canonical mode, no echo (matches the menus' and
-                # input prompts' pre-shim termios setup)
-                settings = termios.tcgetattr(sys.stdin)
-                settings[3] = settings[3] & ~(termios.ICANON | termios.ECHO)
-                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, settings)
+            # No canonical mode, no echo; ISIG stays on so Ctrl+C
+            # still raises KeyboardInterrupt. Same state as the
+            # pre-shim menus and input prompts.
+            settings = termios.tcgetattr(sys.stdin)
+            settings[3] = settings[3] & ~(termios.ICANON | termios.ECHO)
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, settings)
         self._enabled = True
 
     def disable(self) -> None:
@@ -188,7 +275,9 @@ class RawTerminal:
         if sys.platform == "win32":
             if self._stdin_handle is None or self._old_mode is None:
                 raise RuntimeError("RawTerminal disabled before enable()")
-            _set_console_mode(self._stdin_handle, self._old_mode)
+            _set_console_mode(
+                self._stdin_handle, self._old_mode, "restoring terminal"
+            )
         else:
             if self._old_settings is None:
                 raise RuntimeError("RawTerminal disabled before enable()")

{urkit-0.4.3 → urkit-0.4.5}/src/urkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urkit
-Version: 0.4.3
+Version: 0.4.5
 Summary: Universal Robots e-Series control toolkit built on ur_rtde
 Author: URKit Contributors
 License: MIT