Renamed CompletionResultsBase.from_strings() to from_values().

Added CompletionResultsBase.to_strings().

Author: kmvanbrunt

cmd2/argparse_completer.py

@@ -6,7 +6,10 @@
 import argparse
 import dataclasses
 import inspect
-from collections import deque
+from collections import (
+    defaultdict,
+    deque,
+)
 from collections.abc import Sequence
 from typing import (
     IO,
@@ -247,15 +250,14 @@ def complete(
         used_flags: set[str] = set()
 
         # Keeps track of arguments we've seen and any tokens they consumed
-        consumed_arg_values: dict[str, list[str]] = {}  # dict(arg_name -> list[tokens])
+        consumed_arg_values: dict[str, list[str]] = defaultdict(list)
 
         # Completed mutually exclusive groups
         completed_mutex_groups: dict[argparse._MutuallyExclusiveGroup, argparse.Action] = {}
 
         def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
             """Consume token as an argument."""
             arg_state.count += 1
-            consumed_arg_values.setdefault(arg_state.action.dest, [])
             consumed_arg_values[arg_state.action.dest].append(arg_token)
 
         #############################################################################################
@@ -315,7 +317,11 @@ def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
 
                 if action is not None:
                     self._update_mutex_groups(action, completed_mutex_groups, used_flags, remaining_positionals)
-                    if isinstance(
+
+                    # Check if the action type allows the same flag to be provided multiple times.
+                    # Reusable actions (append, count, extend) preserve their history so the
+                    # completion logic knows which values have already been 'consumed'.
+                    if not isinstance(
                         action,
                         (
                             argparse._AppendAction,
@@ -324,16 +330,12 @@ def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
                             argparse._ExtendAction,
                         ),
                     ):
-                        # Flags with actions set to append, append_const, count, and extend can be reused.
-                        # Therefore don't erase any tokens already consumed for this flag.
-                        consumed_arg_values.setdefault(action.dest, [])
-                    else:
-                        # This flag is not reusable, so mark that we've seen it
+                        # For standard 'overwrite' actions (e.g., --store), providing the flag
+                        # again resets its state. We mark the flags as 'used' to potentially
+                        # filter them from future completion results and clear any previously
+                        # recorded values for this destination.
                         used_flags.update(action.option_strings)
-
-                        # It's possible we already have consumed values for this flag if it was used
-                        # earlier in the command line. Reset them now for this use of it.
-                        consumed_arg_values[action.dest] = []
+                        consumed_arg_values[action.dest].clear()
 
                     new_arg_state = _ArgumentState(action)
 
@@ -554,15 +556,15 @@ def _complete_flags(self, text: str, line: str, begidx: int, endidx: int, used_f
                     match_against.append(flag)
 
         # Build a dictionary linking actions with their matched flag names
-        matched_actions: dict[argparse.Action, list[str]] = {}
+        matched_actions: dict[argparse.Action, list[str]] = defaultdict(list)
 
         # Keep flags sorted in the order provided by argparse so our completion
         # suggestions display the same as argparse help text.
         matched_flags = self._cmd2_app.basic_complete(text, line, begidx, endidx, match_against, sort=False)
 
-        for item in matched_flags.items:
-            action = self._flag_to_action[item.text]
-            matched_actions.setdefault(action, []).append(item.text)
+        for flag in matched_flags.to_strings():
+            action = self._flag_to_action[flag]
+            matched_actions[action].append(flag)
 
         # For completion suggestions, group matched flags by action
         items: list[CompletionItem] = []

cmd2/cmd2.py

@@ -1178,7 +1178,7 @@ def build_settables(self) -> None:
         def get_allow_style_choices(_cli_self: Cmd) -> Choices:
             """Complete allow_style values."""
             styles = [val.name.lower() for val in ru.AllowStyle]
-            return Choices.from_strings(styles)
+            return Choices.from_values(styles)
 
         def allow_style_type(value: str) -> ru.AllowStyle:
             """Convert a string value into an ru.AllowStyle."""
@@ -1858,7 +1858,7 @@ def delimiter_complete(
         if not basic_completions:
             return Completions()
 
-        match_strings = [item.text for item in basic_completions]
+        match_strings = basic_completions.to_strings()
 
         # Calculate what portion of the match we are completing
         common_prefix = os.path.commonprefix(match_strings)
@@ -2400,13 +2400,13 @@ def _perform_completion(
 
         # Check if we need to add an opening quote
         if not completion_token_quote:
-            current_texts = [item.text for item in completions]
+            matches = completions.to_strings()
 
-            if any(' ' in text for text in current_texts):
+            if any(' ' in match for match in matches):
                 _add_opening_quote = True
 
                 # Determine best quote (single vs double) based on text content
-                _quote_char = "'" if any('"' in t for t in current_texts) else '"'
+                _quote_char = "'" if any('"' in t for t in matches) else '"'
 
         # Check if we need to remove text from the beginning of completions
         elif text_to_remove:

cmd2/completion.py

@@ -53,7 +53,7 @@
 class CompletionItem:
     """A single completion result."""
 
-    # The underlying object this completion represents (e.g., a Path, Enum, or int).
+    # The underlying object this completion represents (e.g., str, int, Path).
     # This is used to support argparse choices validation.
     value: Any = field(kw_only=False)
 
@@ -148,15 +148,19 @@ def __post_init__(self) -> None:
         object.__setattr__(self, "items", tuple(unique_items))
 
     @classmethod
-    def from_strings(cls, strings: Sequence[str], *, is_sorted: bool = False) -> Self:
-        """Create a completion results instance from a sequence of strings.
+    def from_values(cls, values: Sequence[str], *, is_sorted: bool = False) -> Self:
+        """Create a completion results instance from a sequence of arbitrary objects.
 
-        :param strings: the raw strings to be converted into CompletionItems.
-        :param is_sorted: whether the strings are already in the desired order.
+        :param values: the raw objects (e.g. strs, ints, Paths) to be converted into CompletionItems.
+        :param is_sorted: whether the values are already in the desired order.
         """
-        items = [CompletionItem(s) for s in strings]
+        items = [CompletionItem(value=v) for v in values]
         return cls(items=items, is_sorted=is_sorted)
 
+    def to_strings(self) -> tuple[str, ...]:
+        """Return a tuple of the completion strings (the 'text' field of each item)."""
+        return tuple(item.text for item in self.items)
+
     # --- Sequence Protocol Functions ---
 
     def __bool__(self) -> bool:

cmd2/utils.py

@@ -118,7 +118,7 @@ def __init__(
 
             def get_bool_choices(_cmd2_self: "CommandParent") -> Choices:
                 """Tab complete lowercase boolean values."""
-                return Choices.from_strings(['true', 'false'])
+                return Choices.from_values(['true', 'false'])
 
             val_type = to_bool
             choices_provider = get_bool_choices

tests/test_cmd2.py

@@ -3297,7 +3297,7 @@ def help_has_helper_funcs(self) -> None:
         self.poutput('Help for has_helper_funcs')
 
     def complete_has_helper_funcs(self, *args) -> Completions:
-        return Completions.from_strings(['result'])
+        return Completions.from_values(['result'])
 
     @cmd2.with_category(category_name)
     def do_has_no_helper_funcs(self, arg) -> None: