Add a _StoreTrueArgument class

Author: DanielNoord

pylint/config/argument.py

@@ -158,3 +158,47 @@ def __init__(
         See:
         https://docs.python.org/3/library/argparse.html#metavar
         """
+
+
+class _StoreTrueArgument:
+    """Class representing a 'store_true' argument to be passed by an argparse.ArgumentsParser.
+
+    This is based on the parameters passed to argparse.ArgumentsParser.add_message.
+    See:
+    https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser.add_argument
+    """
+
+    def __init__(
+        self,
+        flags: List[str],
+        action: str,
+        default: _ArgumentTypes,
+        choices: Optional[List[str]],
+        arg_help: str,
+        metavar: str,
+    ) -> None:
+        self.flags = flags
+        """The name of the argument."""
+
+        self.action = action
+        """The action to perform with the argument."""
+
+        self.default = default
+        """The default value of the argument."""
+
+        self.choices = choices
+        """A list of possible choices for the argument.
+
+        None if there are no restrictions.
+        """
+
+        # argparse uses % formatting on help strings, so a % needs to be escaped
+        self.help = arg_help.replace("%", "%%")
+        """The description of the argument."""
+
+        self.metavar = metavar
+        """The metavar of the argument.
+
+        See:
+        https://docs.python.org/3/library/argparse.html#metavar
+        """

pylint/config/arguments_manager.py

@@ -5,9 +5,9 @@
 """Arguments manager class used to handle command-line arguments and options."""
 
 import argparse
-from typing import TYPE_CHECKING, Dict, List
+from typing import TYPE_CHECKING, Dict, List, Union
 
-from pylint.config.argument import _Argument
+from pylint.config.argument import _Argument, _StoreTrueArgument
 from pylint.config.exceptions import UnrecognizedArgumentAction
 from pylint.config.utils import _convert_option_to_argument
 
@@ -43,7 +43,9 @@ def _register_options_provider(self, provider: "checkers.BaseChecker") -> None:
         # TODO: Investigate performance impact of loading default arguments on every call
         self._load_default_argument_values()
 
-    def _add_arguments_to_parser(self, section: str, argument: _Argument) -> None:
+    def _add_arguments_to_parser(
+        self, section: str, argument: Union[_Argument, _StoreTrueArgument]
+    ) -> None:
         """Iterates over all argument sections and add them to the parser object."""
         try:
             section_group = self._argument_groups_dict[section]
@@ -54,10 +56,11 @@ def _add_arguments_to_parser(self, section: str, argument: _Argument) -> None:
 
     @staticmethod
     def _add_parser_option(
-        section_group: argparse._ArgumentGroup, argument: _Argument
+        section_group: argparse._ArgumentGroup,
+        argument: Union[_Argument, _StoreTrueArgument],
     ) -> None:
         """Add an argument."""
-        if argument.action == "store":
+        if isinstance(argument, _Argument):
             section_group.add_argument(
                 *argument.flags,
                 action=argument.action,
@@ -67,6 +70,15 @@ def _add_parser_option(
                 metavar=argument.metavar,
                 choices=argument.choices,
             )
+        elif isinstance(argument, _StoreTrueArgument):
+            section_group.add_argument(
+                *argument.flags,
+                action=argument.action,
+                default=argument.default,
+                help=argument.help,
+                metavar=argument.metavar,
+                choices=argument.choices,
+            )
         else:
             raise UnrecognizedArgumentAction
 

pylint/config/utils.py

@@ -5,15 +5,17 @@
 """Utils for arguments/options parsing and handling."""
 
 
-from typing import Any, Dict
+from typing import Any, Dict, Union
 
-from pylint.config.argument import _Argument
+from pylint.config.argument import _Argument, _StoreTrueArgument
 
 IMPLEMENTED_OPTDICT_KEYS = {"action", "default", "type", "choices", "help", "metavar"}
 """This is used to track our progress on accepting all optdict keys."""
 
 
-def _convert_option_to_argument(opt: str, optdict: Dict[str, Any]) -> _Argument:
+def _convert_option_to_argument(
+    opt: str, optdict: Dict[str, Any]
+) -> Union[_Argument, _StoreTrueArgument]:
     """Convert an optdict to an Argument class instance."""
     # See if the optdict contains any keys we don't yet implement
     # pylint: disable-next=fixme
@@ -23,9 +25,19 @@ def _convert_option_to_argument(opt: str, optdict: Dict[str, Any]) -> _Argument:
             print("Unhandled key found in Argument creation:", key)  # pragma: no cover
             print("It's value is:", value)  # pragma: no cover
 
+    action = optdict.get("action", "store")
+    if action == "store_true":
+        return _StoreTrueArgument(
+            flags=[f"--{opt}"],
+            action=action,
+            default=optdict["default"],
+            choices=optdict.get("choices", None),
+            arg_help=optdict["help"],
+            metavar=optdict["metavar"],
+        )
     return _Argument(
         flags=[f"--{opt}"],
-        action=optdict.get("action", "store"),
+        action=action,
         default=optdict["default"],
         arg_type=optdict["type"],
         choices=optdict.get("choices", None),