urkit 0.4.2__tar.gz → 0.4.4__tar.gz

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

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

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

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

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

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

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

@@ -252,25 +252,35 @@ def _interactive_points_filter(points_db: Points, all_points: list[str], points_
                 # that arrives late; wait a bit before treating it as quit.
                 if text == "\x1b":
                     text = text + read_burst(0.2).decode("ascii", errors="replace")
-                if text.endswith("[A"):  # Up arrow - scroll up
+                if "[A" in text:  # Up arrow - scroll up
                     scroll = max(0, scroll - 1)
                     needs_redraw = True
-                elif text.endswith("[B"):  # Down arrow - scroll down
+                elif "[B" in text:  # Down arrow - scroll down
                     filtered = [p for p in all_points_sorted if filter_str == "" or filter_str.lower() in p.lower()]
                     scroll = min(len(filtered) - 1, scroll + 1) if filtered else 0
                     needs_redraw = True
                 else:
                     # Just ESC (or an unrecognized sequence) — quit
                     break
-            elif text == "\x7f" or text == "\x08":  # Backspace
-                if filter_str:
-                    filter_str = filter_str[:-1]
-                    scroll = 0
-                    needs_redraw = True
-            elif text.isprintable():
-                filter_str += text
-                scroll = 0
-                needs_redraw = True
+            else:
+                # A burst can mix printable chars and backspaces
+                # (fast typing), so process sequentially.
+                quit_requested = False
+                for ch in text:
+                    if ch == "\x03":  # Ctrl+C (raw byte on Windows)
+                        quit_requested = True
+                        break
+                    elif ch == "\x7f" or ch == "\x08":  # Backspace
+                        if filter_str:
+                            filter_str = filter_str[:-1]
+                            scroll = 0
+                            needs_redraw = True
+                    elif ch.isprintable():
+                        filter_str += ch
+                        scroll = 0
+                        needs_redraw = True
+                if quit_requested:
+                    break
 
     except KeyboardInterrupt:
         # Ctrl+C — exit gracefully without traceback

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

@@ -583,36 +583,44 @@ def _filter_select_points(
     raw.enable()
 
     try:
+        needs_redraw = True
         while True:
-            # Clear screen and draw
-            sys.stdout.write("\033[2J\033[1;1H")
-            sys.stdout.write(cyan(f"  === {title} ===") + "\n")
-            sys.stdout.write(dim("  Arrows navigate · Type to filter · Enter select · ESC cancel") + "\n\n")
-            sys.stdout.write(f"  {blue('Search:')} {filter_str}\n")
-            sys.stdout.write("  " + dim("─" * 60) + "\n")
-
-            filtered = [p for p in all_points if filter_str == "" or filter_str.lower() in p.lower()]
-
-            # Clamp cursor to valid range
-            if not filtered:
-                cursor = 0
-            elif cursor >= len(filtered):
-                cursor = len(filtered) - 1
-
-            if not filtered:
-                sys.stdout.write(yellow(f"  No points match '{filter_str}'") + "\n")
-                sys.stdout.write("\n  " + dim("Type to search for points...") + "\n")
+            # Redraw only when state changed. Redrawing every poll
+            # iteration (10x/s) is invisible on Linux terminals but
+            # flickers visibly on the Windows console.
+            if needs_redraw:
+                # Clear screen and draw
+                sys.stdout.write("\033[2J\033[1;1H")
+                sys.stdout.write(cyan(f"  === {title} ===") + "\n")
+                sys.stdout.write(dim("  Arrows navigate · Type to filter · Enter select · ESC cancel") + "\n\n")
+                sys.stdout.write(f"  {blue('Search:')} {filter_str}\n")
+                sys.stdout.write("  " + dim("─" * 60) + "\n")
+
+                filtered = [p for p in all_points if filter_str == "" or filter_str.lower() in p.lower()]
+
+                # Clamp cursor to valid range
+                if not filtered:
+                    cursor = 0
+                elif cursor >= len(filtered):
+                    cursor = len(filtered) - 1
+
+                if not filtered:
+                    sys.stdout.write(yellow(f"  No points match '{filter_str}'") + "\n")
+                    sys.stdout.write("\n  " + dim("Type to search for points...") + "\n")
+                else:
+                    sys.stdout.write(blue("  Matching points:") + "\n")
+                    for i, p in enumerate(filtered):
+                        marker = green("►") if i == cursor else " "
+                        highlighted = _highlight_match(p, filter_str)
+                        sys.stdout.write(f"    {marker} {highlighted}\n")
+
+                    sel = green("'" + filtered[cursor] + "'")
+                    sys.stdout.write(f"\n  {dim('Enter')} to select {sel}\n")
+
+                sys.stdout.flush()
+                needs_redraw = False
             else:
-                sys.stdout.write(blue("  Matching points:") + "\n")
-                for i, p in enumerate(filtered):
-                    marker = green("►") if i == cursor else " "
-                    highlighted = _highlight_match(p, filter_str)
-                    sys.stdout.write(f"    {marker} {highlighted}\n")
-
-                sel = green("'" + filtered[cursor] + "'")
-                sys.stdout.write(f"\n  {dim('Enter')} to select {sel}\n")
-
-            sys.stdout.flush()
+                filtered = [p for p in all_points if filter_str == "" or filter_str.lower() in p.lower()]
 
             # Wait for input, then read the full burst (e.g. the
             # 3-byte \x1b[A arrow-key sequence) in one go.
@@ -628,6 +636,7 @@ def _filter_select_points(
             # Decode and parse sequentially, handling multi-byte escape sequences
             text = raw_bytes.decode("ascii", errors="replace")
             i = 0
+            changed = False
             while i < len(text):
                 ch = text[i]
 
@@ -637,8 +646,10 @@ def _filter_select_points(
                         key = text[i + 2]
                         if key == "A":
                             cursor = max(0, cursor - 1)
+                            changed = True
                         elif key == "B":
                             cursor = min(len(filtered) - 1, cursor + 1)
+                            changed = True
                         # Unrecognized CSI sequences are ignored
                         i += 3
                         continue
@@ -652,12 +663,15 @@ def _filter_select_points(
                     return None
                 elif ch == "\x08" or ch == "\x7f":
                     filter_str = filter_str[:-1]
+                    changed = True
                 elif ch == "\x03":
                     return None
                 elif ch.isprintable() and len(filter_str) < 30:
                     filter_str += ch
+                    changed = True
 
                 i += 1
+            needs_redraw = changed
     finally:
         raw.disable()
 
@@ -869,19 +883,25 @@ def _submenu_orient_tcp(
     raw.enable()
 
     try:
+        needs_redraw = True
         while True:
-            sys.stdout.write("\033[2J\033[1;1H")
-            sys.stdout.write(cyan("  === ORIENT TCP ===") + "\n")
-            sys.stdout.write(dim("  Arrows navigate · Enter select · ESC cancel") + "\n\n")
-            sys.stdout.write(blue("  Point tool Z toward:") + "\n")
-            sys.stdout.write("  " + dim("─" * 60) + "\n")
-
-            for i, (label, _direction) in enumerate(_TCP_ORIENT_OPTIONS):
-                marker = green("►") if i == cursor else " "
-                sys.stdout.write(f"    {marker} {label}\n")
+            # Redraw only when the cursor moved. Redrawing every poll
+            # iteration (10x/s) is invisible on Linux terminals but
+            # flickers visibly on the Windows console.
+            if needs_redraw:
+                sys.stdout.write("\033[2J\033[1;1H")
+                sys.stdout.write(cyan("  === ORIENT TCP ===") + "\n")
+                sys.stdout.write(dim("  Arrows navigate · Enter select · ESC cancel") + "\n\n")
+                sys.stdout.write(blue("  Point tool Z toward:") + "\n")
+                sys.stdout.write("  " + dim("─" * 60) + "\n")
+
+                for i, (label, _direction) in enumerate(_TCP_ORIENT_OPTIONS):
+                    marker = green("►") if i == cursor else " "
+                    sys.stdout.write(f"    {marker} {label}\n")
 
-            sys.stdout.write(f"\n  {dim('Enter')} to orient {green(_TCP_ORIENT_OPTIONS[cursor][0])}\n")
-            sys.stdout.flush()
+                sys.stdout.write(f"\n  {dim('Enter')} to orient {green(_TCP_ORIENT_OPTIONS[cursor][0])}\n")
+                sys.stdout.flush()
+                needs_redraw = False
 
             raw_bytes = read_burst(0.1)
             if not raw_bytes:
@@ -894,6 +914,7 @@ def _submenu_orient_tcp(
             text = raw_bytes.decode("ascii", errors="replace")
             i = 0
             selected = None
+            moved = False
             while i < len(text):
                 ch = text[i]
                 if ch == "\x1b":
@@ -901,8 +922,10 @@ def _submenu_orient_tcp(
                         key = text[i + 2]
                         if key == "A":
                             cursor = max(0, cursor - 1)
+                            moved = True
                         elif key == "B":
                             cursor = min(len(_TCP_ORIENT_OPTIONS) - 1, cursor + 1)
+                            moved = True
                         i += 3
                         continue
                     else:
@@ -913,6 +936,7 @@ def _submenu_orient_tcp(
                     return None
                 i += 1
 
+            needs_redraw = moved
             if selected is not None:
                 break
     finally:
@@ -975,22 +999,28 @@ def _submenu_freedrive_axes(
     raw.enable()
 
     try:
+        needs_redraw = True
         while True:
-            sys.stdout.write("\033[2J\033[1;1H")
-            sys.stdout.write(cyan("  === FREEDRIVE AXES ===") + "\n")
-            sys.stdout.write(dim("  Arrows navigate · Space toggle · Enter apply · ESC cancel") + "\n\n")
-            sys.stdout.write("  " + dim("─" * 40) + "\n")
-
-            for i, label in enumerate(_FD_AXIS_LABELS):
-                marker = green("►") if i == cursor else " "
-                state_str = green("ON") if axes[i] else red("OFF")
-                sys.stdout.write(f"    {marker} {label:<6} {state_str}\n")
-
-            sys.stdout.write("  " + dim("─" * 40) + "\n")
-            active = sum(axes)
-            sys.stdout.write(f"\n  {blue('Active axes:')} {green(str(active))} / 6\n")
-            sys.stdout.write(f"  {dim('Enter')} to apply · {dim('ESC')} to cancel\n")
-            sys.stdout.flush()
+            # Redraw only when the cursor moved or an axis toggled.
+            # Redrawing every poll iteration (10x/s) is invisible on
+            # Linux terminals but flickers visibly on the Windows console.
+            if needs_redraw:
+                sys.stdout.write("\033[2J\033[1;1H")
+                sys.stdout.write(cyan("  === FREEDRIVE AXES ===") + "\n")
+                sys.stdout.write(dim("  Arrows navigate · Space toggle · Enter apply · ESC cancel") + "\n\n")
+                sys.stdout.write("  " + dim("─" * 40) + "\n")
+
+                for i, label in enumerate(_FD_AXIS_LABELS):
+                    marker = green("►") if i == cursor else " "
+                    state_str = green("ON") if axes[i] else red("OFF")
+                    sys.stdout.write(f"    {marker} {label:<6} {state_str}\n")
+
+                sys.stdout.write("  " + dim("─" * 40) + "\n")
+                active = sum(axes)
+                sys.stdout.write(f"\n  {blue('Active axes:')} {green(str(active))} / 6\n")
+                sys.stdout.write(f"  {dim('Enter')} to apply · {dim('ESC')} to cancel\n")
+                sys.stdout.flush()
+                needs_redraw = False
 
             raw_bytes = read_burst(0.1)
             if not raw_bytes:
@@ -998,6 +1028,7 @@ def _submenu_freedrive_axes(
             text = raw_bytes.decode("ascii", errors="replace")
             i = 0
             applied = False
+            changed = False
             while i < len(text):
                 ch = text[i]
                 if ch == "\x1b":
@@ -1005,20 +1036,24 @@ def _submenu_freedrive_axes(
                         key = text[i + 2]
                         if key == "A":
                             cursor = max(0, cursor - 1)
+                            changed = True
                         elif key == "B":
                             cursor = min(5, cursor + 1)
+                            changed = True
                         i += 3
                         continue
                     else:
                         return  # ESC → cancel
                 if ch == " ":
                     axes[cursor] = 1 - axes[cursor]
+                    changed = True
                 elif ch == "\n" or ch == "\r":
                     applied = True
                 elif ch == "\x03":
                     return
                 i += 1
 
+            needs_redraw = changed
             if applied:
                 break
     finally:

{urkit-0.4.2 → urkit-0.4.4}/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
@@ -38,13 +38,21 @@ if sys.platform == "win32":
 else:
     import select
     import termios
-    import tty
 
 if sys.platform == "win32":
     # CDLL is used instead of WinDLL because ctypes.WinDLL is only
     # exposed in the Windows type stubs; on 64-bit Windows both use
     # the same calling convention.
     _kernel32 = ctypes.CDLL("kernel32", use_last_error=True)
+    # Declare prototypes. The default restype is c_int, which would
+    # truncate 64-bit HANDLE values from GetStdHandle.
+    _kernel32.GetStdHandle.argtypes = [ctypes.c_int]
+    _kernel32.GetStdHandle.restype = ctypes.c_void_p
+    _kernel32.GetConsoleMode.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    _kernel32.SetConsoleMode.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
     _STD_INPUT_HANDLE = -10
     _STD_OUTPUT_HANDLE = -11
     _ENABLE_PROCESSED_INPUT = 0x0001
@@ -52,9 +60,10 @@ if sys.platform == "win32":
     _ENABLE_ECHO_INPUT = 0x0004
     _ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
 
-    # msvcrt extended-key scan codes (after the 0xE0/0x00 prefix byte)
-    # mapped to the ANSI CSI sequences a Unix terminal emits for the
-    # same key.
+    # msvcrt extended-key scan codes after the 0xE0 prefix byte, mapped
+    # to the ANSI CSI sequences a Unix terminal emits for the same key.
+    # Keys carrying the 0x00 prefix are not translated: their scan codes
+    # overlap with arrow keys, and the CLIs don't use them.
     _EXTENDED_KEYS: dict[int, str] = {
         0x48: "\x1b[A",  # Up
         0x50: "\x1b[B",  # Down
@@ -68,18 +77,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.
@@ -92,7 +118,9 @@ 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
@@ -138,10 +166,18 @@ 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, 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
@@ -150,11 +186,17 @@ class RawTerminal:
                     | _ENABLE_LINE_INPUT
                     | _ENABLE_ECHO_INPUT
                 ),
+                "entering raw mode",
             )
             _enable_ansi_output()
         else:
             self._old_settings = termios.tcgetattr(sys.stdin)
-            tty.setcbreak(sys.stdin.fileno())
+            # 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:
@@ -164,7 +206,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()")
@@ -188,13 +232,18 @@ def _win_read_pending() -> bytes:
         out = bytearray()
         while msvcrt.kbhit():
             byte = msvcrt.getch()
-            if byte in (b"\xe0", b"\x00"):
-                code = msvcrt.getch()
+            if byte == b"\xe0":
+                # getch() returns bytes; the scan code dict is keyed
+                # by int, so take the single byte's ordinal
+                code = msvcrt.getch()[0]
                 seq = _EXTENDED_KEYS.get(code)
                 if seq is None:
-                    # Unrecognized function key (F1-F12 etc.): drop it
+                    # Unrecognized extended key: drop it
                     continue
                 out += seq.encode("ascii")
+            elif byte == b"\x00":
+                # Untranslated extended prefix: consume the scan code
+                msvcrt.getch()
             else:
                 out += byte
         return bytes(out)

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

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