urkit 0.4.2__tar.gz → 0.4.3__tar.gz

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

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

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

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

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

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

{urkit-0.4.2 → urkit-0.4.3}/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.3}/src/urkit/cli/teach.py

@@ -442,11 +442,13 @@ 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.
-_raw_terminal = RawTerminal()
+# 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)
 
 
 def _configure_terminal() -> None:
-    """Enter raw terminal mode (no canonical, no echo)."""
+    """Enter raw terminal mode (no canonical, echo on)."""
     _raw_terminal.enable()
 
 
@@ -583,36 +585,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 +638,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 +648,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 +665,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 +885,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 +916,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 +924,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 +938,7 @@ def _submenu_orient_tcp(
                     return None
                 i += 1
 
+            needs_redraw = moved
             if selected is not None:
                 break
     finally:
@@ -975,22 +1001,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 +1030,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 +1038,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.3}/src/urkit/cli/terminal.py

@@ -45,6 +45,15 @@ if sys.platform == "win32":
     # 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 +61,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
@@ -126,7 +136,15 @@ class RawTerminal:
         raw.disable()   # idempotent, safe to call multiple times
     """
 
-    def __init__(self) -> None:
+    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
         self._enabled = False
         self._old_settings: list[Any] | None = None
         self._old_mode: int | None = None
@@ -139,22 +157,28 @@ class RawTerminal:
         if sys.platform == "win32":
             self._stdin_handle = _kernel32.GetStdHandle(_STD_INPUT_HANDLE)
             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.
-            _set_console_mode(
-                self._stdin_handle,
-                self._old_mode
-                & ~(
-                    _ENABLE_PROCESSED_INPUT
-                    | _ENABLE_LINE_INPUT
-                    | _ENABLE_ECHO_INPUT
-                ),
+            # 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
             )
+            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)
-            tty.setcbreak(sys.stdin.fileno())
+            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)
         self._enabled = True
 
     def disable(self) -> None:
@@ -188,13 +212,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.3}/src/urkit.egg-info/PKG-INFO

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