Removed defaultdicts to simplify some code.

Author: kmvanbrunt

cmd2/argparse_completer.py

@@ -6,10 +6,7 @@
 import argparse
 import dataclasses
 import inspect
-from collections import (
-    defaultdict,
-    deque,
-)
+from collections import deque
 from collections.abc import (
     Mapping,
     MutableSequence,
@@ -251,15 +248,15 @@ 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]] = defaultdict(list)
+        consumed_arg_values: dict[str, list[str]] = {}
 
         # 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[arg_state.action.dest].append(arg_token)
+            consumed_arg_values.setdefault(arg_state.action.dest, []).append(arg_token)
 
         #############################################################################################
         # Parse all but the last token
@@ -336,7 +333,7 @@ def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
                         # filter them from future completion results and clear any previously
                         # recorded values for this destination.
                         used_flags.update(action.option_strings)
-                        consumed_arg_values[action.dest].clear()
+                        consumed_arg_values[action.dest] = []
 
                     new_arg_state = _ArgumentState(action)
 
@@ -362,7 +359,6 @@ def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
                     # Are we at a subcommand? If so, forward to the matching completer
                     if self._subcommand_action is not None and action == self._subcommand_action:
                         if token in self._subcommand_action.choices:
-                            # Merge self._parent_tokens and consumed_arg_values
                             parent_tokens = {**self._parent_tokens, **consumed_arg_values}
 
                             # Include the subcommand name if its destination was set
@@ -557,15 +553,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]] = defaultdict(list)
+        matched_actions: dict[argparse.Action, list[str]] = {}
 
         # 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 flag in matched_flags.to_strings():
             action = self._flag_to_action[flag]
-            matched_actions[action].append(flag)
+            matched_actions.setdefault(action, []).append(flag)
 
         # For completion suggestions, group matched flags by action
         items: list[CompletionItem] = []

cmd2/cmd2.py

@@ -42,7 +42,6 @@
 import time
 from code import InteractiveConsole
 from collections import (
-    defaultdict,
     deque,
     namedtuple,
 )
@@ -4223,7 +4222,7 @@ def _build_command_info(self) -> tuple[dict[str, list[str]], list[str], list[str
 
         # Get a sorted list of visible command names
         visible_commands = sorted(self.get_visible_commands(), key=utils.DEFAULT_STR_SORT_KEY)
-        cmds_cats: dict[str, list[str]] = defaultdict(list)
+        cmds_cats: dict[str, list[str]] = {}
         cmds_undoc: list[str] = []
 
         for command in visible_commands:
@@ -4238,16 +4237,21 @@ def _build_command_info(self) -> tuple[dict[str, list[str]], list[str], list[str
                 # Non-argparse commands can have help_functions for their documentation
                 has_help_func = not has_parser
 
+            # Determine the category
+            category: str | None = None
+
             if hasattr(func, constants.CMD_ATTR_HELP_CATEGORY):
-                category: str = getattr(func, constants.CMD_ATTR_HELP_CATEGORY)
-                cmds_cats[category].append(command)
+                category = getattr(func, constants.CMD_ATTR_HELP_CATEGORY)
             elif func.__doc__ or has_help_func or has_parser:
-                # Determine the category based on the defining class
                 defining_cls = get_defining_class(func)
                 category = getattr(defining_cls, 'DEFAULT_CATEGORY', self.DEFAULT_CATEGORY)
-                cmds_cats[category].append(command)
+
+            # Store the command
+            if category is not None:
+                cmds_cats.setdefault(category, []).append(command)
             else:
                 cmds_undoc.append(command)
+
         return cmds_cats, cmds_undoc, help_topics
 
     @classmethod