urkit 0.4.4__tar.gz → 0.4.6__tar.gz

{urkit-0.4.4 → urkit-0.4.6}/PKG-INFO

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

{urkit-0.4.4 → urkit-0.4.6}/pyproject.toml

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

{urkit-0.4.4 → urkit-0.4.6}/src/urkit/__init__.py

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

{urkit-0.4.4 → urkit-0.4.6}/src/urkit/cli/points.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.table import Table
 
+from urkit import __version__
 from urkit.config import _load_config as load_config
 from urkit.cli.colors import blue, cyan, dim, yellow
 from urkit.cli.terminal import RawTerminal, read_burst, wait_input, warn_if_windows
@@ -158,6 +159,7 @@ def _interactive_points_filter(points_db: Points, all_points: list[str], points_
                 # Clear screen and draw header
                 sys.stdout.write("\033[2J\033[1;1H")
                 sys.stdout.write(cyan("  === POINT EXPLORER ===") + "\n")
+                sys.stdout.write(dim(f"  urkit {__version__}") + "\n")
                 sys.stdout.write(dim("  Type to search · ↑↓ scroll · Enter reload · ESC quit") + "\n\n")
                 sys.stdout.write(f"  {blue('Search:')} {filter_str}\n")
                 if refresh_error:

{urkit-0.4.4 → urkit-0.4.6}/src/urkit/cli/teach.py

@@ -19,14 +19,19 @@ import os
 import signal
 import sys
 import time
+import traceback
 from pathlib import Path
 
 import yaml
 
+from urkit import __version__
 from urkit.cli.colors import blue, cyan, dim, green, red, yellow
 from urkit.cli.terminal import (
     RawTerminal,
+    input_active,
     read_burst,
+    start_interrupt_watcher,
+    stop_interrupt_watcher,
     wait_input,
     warn_if_windows,
 )
@@ -295,6 +300,7 @@ def _draw_screen(
     # Header
     lines.append(dim("=" * width))
     lines.append(cyan("  === URKit Teach Pendant ===").center(width))
+    lines.append(dim(f"  urkit {__version__}").center(width))
     lines.append(cyan(f"  IP: {robot.ip}").center(width))
     if expert_mode:
         lines.append(yellow("  EXPERT MODE").center(width))
@@ -475,6 +481,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):
@@ -511,6 +518,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()
@@ -624,7 +632,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(
@@ -739,11 +751,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")
@@ -761,6 +777,9 @@ def _submenu_goto_point(
     except URKitConnectionError:
         raise
     except Exception as e:
+        logger.debug(
+            "goto move failed: %s\n%s", e, traceback.format_exc()
+        )
         messages.append(f"Error: {e}")
 
 
@@ -903,7 +922,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(
@@ -1022,7 +1045,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")
@@ -1183,12 +1210,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()
@@ -1207,9 +1234,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.
@@ -1225,6 +1259,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()
@@ -1239,39 +1288,49 @@ 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
 
                 # Exit
                 if key == "\x1b" or key == "\x03":
+                    # The main loop owns cleanup from here; the watcher
+                    # must not fire a second stop/restore in parallel.
+                    stop_interrupt_watcher()
                     if state["freedrive"]:
                         try:
                             robot.disable_freedrive()
@@ -1317,6 +1376,9 @@ def _teach_pendant(
                         moved = True
                         last_move_t = time.monotonic()
                     except MotionError as e:
+                        logger.debug(
+                            "move key %r failed: %s\n%s", key, e, traceback.format_exc()
+                        )
                         messages.append(f"Error: {e}")
 
                 # --- Step size ---
@@ -1527,6 +1589,7 @@ def _teach_pendant(
             print(f"\n{red('Fault:')} {e}")
         finally:
             # Stop monitor and restore signal handler
+            stop_interrupt_watcher()
             monitor.stop()
             if _old_sigalrm is not None:
                 signal.signal(signal.SIGALRM, _old_sigalrm)

{urkit-0.4.4 → urkit-0.4.6}/src/urkit/cli/terminal.py

@@ -30,8 +30,9 @@ 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
@@ -126,6 +127,112 @@ if sys.platform == "win32":
             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."""
+
+
+watcher_stop = threading.Event()
+"""Set when the CLI begins its own shutdown (normal exit, fault exit,
+Ctrl+C in the main loop). The Windows interrupt watcher exits quietly
+without firing, so it cannot race the main thread's cleanup (double
+robot stop, double terminal restore)."""
+
+
+def stop_interrupt_watcher() -> None:
+    """Tell the interrupt watcher to exit quietly. No-op on non-Windows."""
+    watcher_stop.set()
+
+
+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 _where_blocked() -> None:
+        # Diagnostic: report where the main thread was stuck so the
+        # next occurrence can be diagnosed (usually a blocking socket
+        # read inside ur_rtde with no timeout).
+        frame = sys._current_frames().get(threading.main_thread().ident)
+        if frame is None:
+            return
+        code = frame.f_code
+        sys.stderr.write(
+            "[urkit] main thread blocked in "
+            f"{os.path.basename(code.co_filename)}:{frame.f_lineno} "
+            f"in {code.co_name}\n"
+        )
+        sys.stderr.flush()
+
+    def _run() -> None:
+        backoff = 0.0
+        while not watcher_stop.is_set():
+            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:
+                _where_blocked()
+                on_fire(reason)
+                return
+            try:
+                if not msvcrt.kbhit():
+                    time.sleep(0.05)
+                    continue
+                byte = msvcrt.getch()
+            except OSError:
+                # Console is closing (shutdown in progress). The watcher
+                # is best-effort; exit quietly instead of dying with a
+                # traceback that races the main thread's exit.
+                return
+            if byte == b"\x03":
+                _where_blocked()
+                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.
+            try:
+                msvcrt.ungetch(byte[0])
+            except OSError:
+                return
+            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.
 

{urkit-0.4.4 → urkit-0.4.6}/src/urkit/motion.py

@@ -30,17 +30,26 @@ def _suppress_rtde_stderr() -> Iterator[None]:
     to raw stderr (fd 2) on every call when the script is stopped.
     This context manager suppresses those messages by redirecting fd 2
     around the call.
+
+    Diagnostic: set URKIT_RTDE_STDERR=<path> to capture the suppressed
+    output in a file (append mode) instead. ur_rtde move failures are
+    reported there and nowhere else, so this is the only way to see
+    why a move was rejected.
     """
-    devnull = os.open(os.devnull, os.O_WRONLY)
+    capture_path = os.environ.get("URKIT_RTDE_STDERR")
+    if capture_path:
+        target_fd = os.open(capture_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND)
+    else:
+        target_fd = os.open(os.devnull, os.O_WRONLY)
     old_stderr = os.dup(2)
     try:
-        os.dup2(devnull, 2)
+        os.dup2(target_fd, 2)
         sys.stderr.flush()
         yield
     finally:
         os.dup2(old_stderr, 2)
         os.close(old_stderr)
-        os.close(devnull)
+        os.close(target_fd)
 
 if TYPE_CHECKING:
     from rtde_control import RTDEControlInterface
@@ -151,7 +160,14 @@ class Motion:
                 "movej: joints=%s, vel=%.3f, acc=%.3f, async=%s", joints, vel, acc, asynchronous
             )
             with _suppress_rtde_stderr():
-                self._rtde_c.moveJ(joints, vel, acc, asynchronous=asynchronous)
+                ok = self._rtde_c.moveJ(joints, vel, acc, asynchronous=asynchronous)
+            if ok is False:
+                raise MotionError(
+                    "moveJ rejected by the controller: the RTDE control script "
+                    "stopped, the robot entered a stop state, or the command "
+                    "timed out. Set URKIT_RTDE_STDERR=<file> to capture "
+                    "ur_rtde's error output."
+                )
         except MotionError:
             raise
         except Exception as e:
@@ -197,7 +213,14 @@ class Motion:
                 "movel: pose=%s, vel=%.3f, acc=%.3f, async=%s", pose, vel, acc, asynchronous
             )
             with _suppress_rtde_stderr():
-                self._rtde_c.moveL(pose, vel, acc, asynchronous=asynchronous)
+                ok = self._rtde_c.moveL(pose, vel, acc, asynchronous=asynchronous)
+            if ok is False:
+                raise MotionError(
+                    "moveL rejected by the controller: the RTDE control script "
+                    "stopped, the robot entered a stop state, or the command "
+                    "timed out. Set URKIT_RTDE_STDERR=<file> to capture "
+                    "ur_rtde's error output."
+                )
         except MotionError:
             raise
         except Exception as e:
@@ -249,7 +272,14 @@ class Motion:
                 current, target, frame.name, vel, acc,
             )
             with _suppress_rtde_stderr():
-                self._rtde_c.moveL(target, vel, acc)
+                ok = self._rtde_c.moveL(target, vel, acc)
+            if ok is False:
+                raise MotionError(
+                    "moveL rejected by the controller: the RTDE control script "
+                    "stopped, the robot entered a stop state, or the command "
+                    "timed out. Set URKIT_RTDE_STDERR=<file> to capture "
+                    "ur_rtde's error output."
+                )
         except MotionError:
             raise
         except Exception as e:

{urkit-0.4.4 → urkit-0.4.6}/src/urkit.egg-info/PKG-INFO

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