console-window 1.3.4__tar.gz → 1.4.1__tar.gz

{console_window-1.3.4 → console_window-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 1.3.4
+Version: 1.4.1
 Summary: A robust curses wrapper for creating Text User Interfaces (TUIs).
 Author-email: Joe Defen <joedef@duck.com>
 Requires-Python: >=3.8

{console_window-1.3.4 → console_window-1.4.1}/console_window/ConsoleWindow.py

@@ -479,70 +479,198 @@ def restore_ctrl_c():
 
 
 class InlineConfirmation:
-    """Manages inline confirmation prompts for wipe/verify operations"""
+    """
+    Manages stateful inline confirmation prompts for destructive or critical operations.
+
+    This class handles the transition from standard application input to a
+    confirmation sub-state, supporting several verification modes. When a match
+    is found in 'choices' mode, the input_buffer is updated to the full
+    canonical string so the calling application can use it directly.
+
+    Modes:
+    - 'Y'/'y': Single-key immediate confirmation.
+    - 'yes'/'YES': Explicit string confirmation (case-sensitive for 'YES').
+    - 'identity': Requires typing a specific string (e.g., a device node like 'sda1').
+    - 'choices': Flexible matching against a list of valid strings.
+
+    :param min_abbrev_chars: Minimum characters required for abbreviated choice matching.
+                             When None (default), automatically calculates based on choices:
+                             (min chars to disambiguate) + 1, capped at longest choice length.
+    :type min_abbrev_chars: int or None
+
+    Methods:
+    - get_hint(): Returns a hint string when input_buffer is empty (display in dimmed/italic style)
+    """
+    MODES = 'Y y YES yes identity choices'.split()
 
-    def __init__(self):
+    def __init__(self, min_abbrev_chars=None):
         self.active = False
-        self.confirm_type = None  # 'wipe' or 'verify'
-        self.partition_name = None
+        self.action_type = None  # e.g., 'wipe' or 'verify'
+        self.identity = None     # e.g., 'sda1'
+        self.choices = None
         self.input_buffer = ''
-        self.mode = None  # 'Y', 'y', 'YES', 'yes', 'device'
+        self.mode = None
+        self.min_abbrev_chars = min_abbrev_chars
+        self._calculated_min_abbrev = None  # Cached calculated value
 
-    def start(self, confirm_type, partition_name, mode):
-        """Start a confirmation prompt"""
+    def start(self, action_type=None, identity=None, choices=None, mode=None, min_abbrev_chars=None):
         self.active = True
-        self.confirm_type = confirm_type
-        self.partition_name = partition_name
+        self.action_type = action_type
+        self.identity = identity
+        self.choices = (choices if isinstance(choices, (list, tuple))
+                    else [choices] if isinstance(choices, str) else None)
         self.input_buffer = ''
-        self.mode = mode
+
+        # Override min_abbrev_chars if provided
+        if min_abbrev_chars is not None:
+            self.min_abbrev_chars = min_abbrev_chars
+            self._calculated_min_abbrev = None
+        else:
+            # Reset calculated value so it's recalculated for new choices
+            self._calculated_min_abbrev = None
+
+        # Logic to determine mode based on provided arguments
+        self.mode = 'choices' if self.choices else mode if mode else 'yes'
+        if self.mode not in self.MODES:
+            self.mode = 'yes'
+        if self.mode == 'choices' and not self.choices:
+            self.mode = 'yes'
 
     def cancel(self):
         """Cancel the confirmation"""
         self.active = False
-        self.confirm_type = None
-        self.partition_name = None
+        self.action_type = None
+        self.choices = None
         self.input_buffer = ''
 
-    def get_expected(self):
-        """Get the expected input string"""
-        if self.mode == 'device':
-            return self.partition_name
-        return self.mode
+    def _calculate_min_abbrev_chars(self):
+        """
+        Calculate minimum prefix length needed to disambiguate choices.
+        Returns: min_length + 1, capped at longest choice length.
+        """
+        if not self.choices or len(self.choices) <= 1:
+            return 1
 
-    def is_single_key(self):
-        """Check if this mode uses single key confirmation"""
-        return self.mode in ('Y', 'y')
+        # Find minimum prefix length to distinguish all choices (case-insensitive)
+        max_len = max(len(c) for c in self.choices)
 
-    def handle_key(self, key):
-        """Handle a key press during confirmation.
+        for prefix_len in range(1, max_len + 1):
+            prefixes = {}
+            for choice in self.choices:
+                prefix = choice[:prefix_len].lower()
+                if prefix in prefixes:
+                    # Collision found
+                    break
+                prefixes[prefix] = choice
+            else:
+                # No collision at this length - we can disambiguate
+                # Add 1 to make errors less likely, but cap at longest choice
+                return min(prefix_len + 1, max_len)
 
-        Returns:
-            'confirmed' - user confirmed
-            'cancelled' - user cancelled (ESC)
-            'continue' - still gathering input
+        # If we get here, choices can't be disambiguated (e.g., "Yes" and "yes")
+        # Still return a reasonable value
+        return max_len
+
+    def _get_effective_min_abbrev_chars(self):
+        """Get the effective min_abbrev_chars value (explicit or calculated)."""
+        if self.min_abbrev_chars is not None:
+            return self.min_abbrev_chars
+
+        # Calculate if not cached
+        if self._calculated_min_abbrev is None:
+            self._calculated_min_abbrev = self._calculate_min_abbrev_chars()
+
+        return self._calculated_min_abbrev
+
+    def _resolve_choice(self):
         """
-        if key == 27:  # ESC
-            return 'cancelled'
+        Tiered matching logic for choices. Returns the full string if 
+        a unique match is found, otherwise None.
+        """
+        buf = self.input_buffer
+        if not buf: return None
+        buf_l = buf.lower()
+
+        # 1. Perfect matches
+        if buf in self.choices: return buf
+        
+        # 2. Case-insensitive matches
+        ci_matches = [c for c in self.choices if c.lower() == buf_l]
+        if len(ci_matches) == 1: return ci_matches[0]
+
+        # 3. Leading substring (min_abbrev_chars+ chars only)
+        min_chars = self._get_effective_min_abbrev_chars()
+        if len(buf) >= min_chars:
+            # Case-sensitive substring
+            ss_matches = [c for c in self.choices if c.startswith(buf)]
+            if len(ss_matches) == 1: return ss_matches[0]
 
-        if self.is_single_key():
-            # Single key confirmation
-            expected = self.get_expected()
-            if key == ord(expected):
+            # Case-insensitive substring
+            ss_ci_matches = [c for c in self.choices if c.lower().startswith(buf_l)]
+            if len(ss_ci_matches) == 1: return ss_ci_matches[0]
+
+        return None
+
+    def handle_key(self, key):
+        if key == 27: return 'cancelled'
+
+        # Handle single-key modes
+        if self.mode in ('Y', 'y'):
+            expected = self.identity if self.mode == 'identity' else self.mode
+            if key == ord(expected[0]):
+                self.input_buffer = expected
                 return 'confirmed'
             return 'continue'
 
-        # Typed confirmation
-        if 32 <= key <= 126:  # Printable ASCII
+        # Handle buffered input
+        if 32 <= key <= 126:
             self.input_buffer += chr(key)
-        elif key in (curses.KEY_BACKSPACE, 127, 8):  # Backspace
+        elif key in (127, 8, curses.KEY_BACKSPACE, 263): # Backspace (all variants)
             self.input_buffer = self.input_buffer[:-1]
-        elif key in (curses.KEY_ENTER, 10):  # ENTER
-            if self.input_buffer == self.get_expected():
+        elif key in (10, 13): # Enter
+            match = None
+            
+            if self.mode == 'choices':
+                match = self._resolve_choice()
+            elif self.mode == 'identity':
+                if self.input_buffer == self.identity: match = self.identity
+            elif self.mode == 'YES':
+                if self.input_buffer == 'YES': match = 'YES'
+            else: # 'yes' or other permissive modes
+                if self.input_buffer.lower() == 'yes': match = self.input_buffer
+            
+            if match:
+                self.input_buffer = match # Canonicalize
                 return 'confirmed'
-            # Wrong input - reset
-            self.input_buffer = ''
+            
+            self.input_buffer = '' # Reset on failure
+
         return 'continue'
 
+    def get_hint(self):
+        """
+        Returns a hint string for display when input_buffer is empty.
+        Intended to be shown in dimmed/italic style.
+        """
+        if self.input_buffer:
+            return ''
+
+        if self.mode in ('Y', 'y'):
+            return f'Press {self.mode}'
+        elif self.mode == 'YES':
+            return 'Type YES + ENTER or ESC'
+        elif self.mode == 'yes':
+            return 'Type yes + ENTER or ESC'
+        elif self.mode == 'identity':
+            return f'Type {self.identity} + ENTER or ESC'
+        elif self.mode == 'choices':
+            if len(self.choices) == 1:
+                return f'Type {self.choices[0]} + ENTER or ESC'
+            else:
+                min_chars = self._get_effective_min_abbrev_chars()
+                return f'{min_chars}+ chars + ENTER or ESC'
+        return ''
+
 
 class IncrementalSearchBar:
     """
@@ -902,6 +1030,14 @@ class OptionSpinner:
 
         # Process each key for scope subtraction
         for key in ns.keys:
+            # Check for conflicts with navigation keys
+            if key in NAVIGATION_KEYS:
+                key_char = chr(key) if 32 <= key < 127 else f'<{key}>'
+                raise ValueError(
+                    f'Key {key_char} ({key}) conflicts with a navigation key. '
+                    f'Navigation keys are reserved for cursor movement and scrolling.'
+                )
+
             # Perform subtraction FIRST: remove new scope from existing options with same key
             for existing_ns in self.options:
                 if key in existing_ns.keys and hasattr(existing_ns, 'effective_scope'):
@@ -1308,7 +1444,7 @@ class ConsoleWindow:
 
     def set_demo_mode(self, enabled):
         """
-        Enable or disable demo mode.
+        Enable or disable demo mode. Passing None will toggle it.
 
         When demo mode is enabled, the last non-navigation key pressed is shown
         in reverse video at the end of the first header line.
@@ -1316,9 +1452,13 @@ class ConsoleWindow:
         :param enabled: True to enable demo mode, False to disable
         :type enabled: bool
         """
-        self.opts.demo_mode = enabled
+        if enabled is None: # toggle if not explicit
+            self.opts.demo_mode = not (self.opts.demo_mode)
+        else:
+            self.opts.demo_mode = bool(enabled)
         if not enabled:
             self.last_demo_key = ''
+        return self.opts.demo_mode
 
     def _format_key_for_demo(self, key):
         """
@@ -2820,17 +2960,20 @@ class ConsoleWindow:
                 break
 
             # App keys...
-            # In passthrough mode, return all printable keys plus special editing keys
-            # Special editing keys: backspace, arrows, home, end
-            editing_keys = {curses.KEY_BACKSPACE, 127, 8, 263,  # backspace variants
-                          curses.KEY_LEFT, curses.KEY_RIGHT,
-                          curses.KEY_HOME, curses.KEY_END,
-                          1, 5}  # Ctrl-A, Ctrl-E
-            if self.passthrough_mode and (32 <= key <= 126 or key in editing_keys or key in self.handled_keys):
-                # Update demo mode tracking for non-navigation keys
-                if self.opts.demo_mode and key not in NAVIGATION_KEYS:
-                    self.last_demo_key = self._format_key_for_demo(key)
-                return key
+            # In passthrough mode, return all keys to the application (printable, editing, and navigation)
+            # This allows InlineConfirmation and IncrementalSearchBar to decide which keys to handle
+            if self.passthrough_mode:
+                # Return all printable chars, editing keys, navigation keys, and handled_keys
+                # Let the application decide what to do with each key
+                editing_keys = {curses.KEY_BACKSPACE, 127, 8, 263,  # backspace variants
+                              curses.KEY_LEFT, curses.KEY_RIGHT,
+                              curses.KEY_HOME, curses.KEY_END,
+                              1, 5}  # Ctrl-A, Ctrl-E
+                if (32 <= key <= 126 or key in editing_keys or key in NAVIGATION_KEYS or key in self.handled_keys):
+                    # Update demo mode tracking for non-navigation keys
+                    if self.opts.demo_mode and key not in NAVIGATION_KEYS:
+                        self.last_demo_key = self._format_key_for_demo(key)
+                    return key
 
             # If relax_handled_keys is False, only pass keys explicitly in handled_keys
             # (Navigation keys will still be handled below)

{console_window-1.3.4 → console_window-1.4.1}/pyproject.toml

@@ -23,7 +23,7 @@ name = "console_window"
 # UNIFIED PROJECT METADATA (Replaces [tool.flit.metadata])
 [project]
 name = "console-window" 
-version = "1.3.4"
+version = "1.4.1"
 description = "A robust curses wrapper for creating Text User Interfaces (TUIs)."
 readme = "README.md"
 requires-python = ">=3.8"