chore: fix rebase error

Author: KelvinChung2000

cmd2/argparse_completer.py

@@ -717,6 +717,16 @@ def print_help(self, tokens: Sequence[str], file: IO[str] | None = None) -> None
 
     def _choices_to_items(self, arg_state: _ArgumentState) -> list[CompletionItem]:
         """Convert choices from action to list of CompletionItems."""
+        action_type = arg_state.action.type
+        if action_type is not None and arg_state.action.choices is None:
+            if isinstance(action_type, type) and issubclass(action_type, enum.Enum):
+                return [CompletionItem(str(m.value), display_meta=m.name) for m in action_type]
+            enum_from_converter = getattr(action_type, '_cmd2_enum_class', None)
+            if isinstance(enum_from_converter, type) and issubclass(enum_from_converter, enum.Enum):
+                return [CompletionItem(str(m.value), display_meta=m.name) for m in enum_from_converter]
+            if getattr(action_type, '__name__', None) == '_parse_bool':
+                return [CompletionItem(v) for v in ['true', 'false', 'yes', 'no', 'on', 'off', '1', '0']]
+
         if arg_state.action.choices is None:
             return []
 
@@ -733,29 +743,6 @@ def _choices_to_items(self, arg_state: _ArgumentState) -> list[CompletionItem]:
                 for name, subparser in arg_state.action.choices.items()
             ]
 
-        choices_callable: ChoicesCallable | None = arg_state.action.get_choices_callable()  # type: ignore[attr-defined]
-        if choices_callable is not None:
-            return choices_callable
-
-        # Type inference: auto-complete from action.type when no explicit
-        # choices or choices_callable is configured.
-        action_type = arg_state.action.type
-        if action_type is not None:
-            if action_type is pathlib.Path or (isinstance(action_type, type) and issubclass(action_type, pathlib.Path)):
-                from .cmd2 import Cmd
-
-                return ChoicesCallable(is_completer=True, to_call=Cmd.path_complete)
-
-            if isinstance(action_type, type) and issubclass(action_type, enum.Enum):
-                return [CompletionItem(str(m.value), display_meta=m.name) for m in action_type]
-
-            enum_from_converter = getattr(action_type, '_cmd2_enum_class', None)
-            if isinstance(enum_from_converter, type) and issubclass(enum_from_converter, enum.Enum):
-                return [CompletionItem(str(m.value), display_meta=m.name) for m in enum_from_converter]
-
-            if getattr(action_type, '__name__', None) == '_parse_bool':
-                return [CompletionItem(v) for v in ['true', 'false', 'yes', 'no', 'on', 'off', '1', '0']]
-
         # Standard choices
         return [
             choice if isinstance(choice, CompletionItem) else CompletionItem(choice) for choice in arg_state.action.choices
@@ -817,6 +804,13 @@ def _complete_arg(
             )
             args.extend([text, line, begidx, endidx])
             completions: Completions = completer(*args, **kwargs)
+        # if is a path type, then use cmd2's path completer
+        elif arg_state.action.type is pathlib.Path or (
+            isinstance(arg_state.action.type, type) and issubclass(arg_state.action.type, pathlib.Path)
+        ):
+            from .cmd2 import Cmd
+
+            completions = Cmd.path_complete(self._cmd2_app, text, line, begidx, endidx)
 
         # Otherwise it uses a choices provider or choices list
         else:

tests/test_annotated.py

@@ -297,13 +297,13 @@ def do_broken(self, cmd2_handler, name: 'NonExistentType'):  # noqa: F821
     def test_choices_provider_overrides_enum_choices(self) -> None:
         action = _get_param_action(_func_choices_provider_on_enum)
         assert action.choices is None
-        assert action.get_choices_callable() is not None  # type: ignore[attr-defined]
+        assert action.get_choices_provider() is not None  # type: ignore[attr-defined]
+        assert action.get_completer() is None  # type: ignore[attr-defined]
 
     def test_completer_overrides_path_choices(self) -> None:
         action = _get_param_action(_func_completer_on_path)
-        cc = action.get_choices_callable()  # type: ignore[attr-defined]
-        assert cc is not None
-        assert cc.is_completer is True
+        assert action.get_choices_provider() is None  # type: ignore[attr-defined]
+        assert action.get_completer() is cmd2.Cmd.path_complete  # type: ignore[attr-defined]
 
     def test_dest_param_raises(self) -> None:
         with pytest.raises(ValueError, match="dest"):
@@ -851,8 +851,8 @@ def __init__(self) -> None:
         super().__init__()
         self._items = ["apple", "banana", "cherry"]
 
-    def item_choices(self) -> list[str]:
-        return self._items
+    def item_choices(self) -> list[cmd2.CompletionItem]:
+        return [cmd2.CompletionItem(item) for item in self._items]
 
     @cmd2.with_annotated
     def do_greet(self, name: str, count: int = 1) -> None:
@@ -987,8 +987,8 @@ def __init__(self) -> None:
         super().__init__()
         self._sports = ["football", "baseball"]
 
-    def sport_choices(self) -> list[str]:
-        return self._sports
+    def sport_choices(self) -> list[cmd2.CompletionItem]:
+        return [cmd2.CompletionItem(sport) for sport in self._sports]
 
     @cmd2.with_annotated
     def do_play(self, sport: Annotated[str, Argument(choices_provider=sport_choices)]) -> None:

tests/test_argparse_completer.py

@@ -1134,38 +1134,6 @@ def test_complete_command_help_no_tokens(ac_app) -> None:
     assert not completions
 
 
-def test_complete_for_arg_type_without_name(ac_app) -> None:
-    from cmd2.argparse_completer import (
-        ArgparseCompleter,
-    )
-
-    parser = Cmd2ArgumentParser()
-    parser.add_argument('value')
-    action = next(action for action in parser._actions if action.dest == 'value')
-
-    class TypeWithoutName:
-        __name__ = property(lambda self: (_ for _ in ()).throw(AttributeError("__name__")))
-
-    action.type = TypeWithoutName()
-    arg_state = argparse_completer._ArgumentState(action)
-    ac = ArgparseCompleter(parser, ac_app)
-
-    assert ac._get_raw_choices(arg_state) is None
-
-
-def test_bool_type_completion_values(ac_app) -> None:
-    from cmd2.annotated import _parse_bool
-
-    parser = Cmd2ArgumentParser()
-    parser.add_argument("flag", type=_parse_bool)
-    ac = argparse_completer.ArgparseCompleter(parser, ac_app)
-    action = next(action for action in parser._actions if action.dest == 'flag')
-    arg_state = argparse_completer._ArgumentState(action)
-
-    completions = ac._complete_arg(text="", line="", begidx=0, endidx=0, arg_state=arg_state, consumed_arg_values={})
-    assert list(completions.to_strings()) == ["0", "1", "false", "no", "off", "on", "true", "yes"]
-
-
 @pytest.mark.parametrize(
     ('flag', 'expected'),
     [