Applied automated pydocstyle refactoring outside of test directories

Author: tleonhardt

cmd2/ansi.py

@@ -28,18 +28,18 @@
 
 
 class AllowStyle(Enum):
-    """Values for ``cmd2.ansi.allow_style``"""
+    """Values for ``cmd2.ansi.allow_style``."""
 
     ALWAYS = 'Always'  # Always output ANSI style sequences
     NEVER = 'Never'  # Remove ANSI style sequences from all output
     TERMINAL = 'Terminal'  # Remove ANSI style sequences if the output is not going to the terminal
 
     def __str__(self) -> str:
-        """Return value instead of enum name for printing in cmd2's set command"""
+        """Return value instead of enum name for printing in cmd2's set command."""
         return str(self.value)
 
     def __repr__(self) -> str:
-        """Return quoted value instead of enum description for printing in cmd2's set command"""
+        """Return quoted value instead of enum description for printing in cmd2's set command."""
         return repr(self.value)
 
 
@@ -124,7 +124,7 @@ def widest_line(text: str) -> int:
 
 
 def style_aware_write(fileobj: IO[str], msg: str) -> None:
-    """Write a string to a fileobject and strip its ANSI style sequences if required by allow_style setting
+    """Write a string to a fileobject and strip its ANSI style sequences if required by allow_style setting.
 
     :param fileobj: the file object being written to
     :param msg: the string being written
@@ -183,63 +183,63 @@ def clear_line(clear_type: int = 2) -> str:
 # Base classes which are not intended to be used directly
 ####################################################################################
 class AnsiSequence:
-    """Base class to create ANSI sequence strings"""
+    """Base class to create ANSI sequence strings."""
 
     def __add__(self, other: Any) -> str:
         """Support building an ANSI sequence string when self is the left operand
-        e.g. Fg.LIGHT_MAGENTA + "hello"
+        e.g. Fg.LIGHT_MAGENTA + "hello".
         """
         return str(self) + str(other)
 
     def __radd__(self, other: Any) -> str:
         """Support building an ANSI sequence string when self is the right operand
-        e.g. "hello" + Fg.RESET
+        e.g. "hello" + Fg.RESET.
         """
         return str(other) + str(self)
 
 
 class FgColor(AnsiSequence):
-    """Base class for ANSI Sequences which set foreground text color"""
+    """Base class for ANSI Sequences which set foreground text color."""
 
 
 class BgColor(AnsiSequence):
-    """Base class for ANSI Sequences which set background text color"""
+    """Base class for ANSI Sequences which set background text color."""
 
 
 ####################################################################################
 # Implementations intended for direct use
 ####################################################################################
 class Cursor:
-    """Create ANSI sequences to alter the cursor position"""
+    """Create ANSI sequences to alter the cursor position."""
 
     @staticmethod
     def UP(count: int = 1) -> str:
-        """Move the cursor up a specified amount of lines (Defaults to 1)"""
+        """Move the cursor up a specified amount of lines (Defaults to 1)."""
         return f"{CSI}{count}A"
 
     @staticmethod
     def DOWN(count: int = 1) -> str:
-        """Move the cursor down a specified amount of lines (Defaults to 1)"""
+        """Move the cursor down a specified amount of lines (Defaults to 1)."""
         return f"{CSI}{count}B"
 
     @staticmethod
     def FORWARD(count: int = 1) -> str:
-        """Move the cursor forward a specified amount of lines (Defaults to 1)"""
+        """Move the cursor forward a specified amount of lines (Defaults to 1)."""
         return f"{CSI}{count}C"
 
     @staticmethod
     def BACK(count: int = 1) -> str:
-        """Move the cursor back a specified amount of lines (Defaults to 1)"""
+        """Move the cursor back a specified amount of lines (Defaults to 1)."""
         return f"{CSI}{count}D"
 
     @staticmethod
     def SET_POS(x: int, y: int) -> str:
-        """Set the cursor position to coordinates which are 1-based"""
+        """Set the cursor position to coordinates which are 1-based."""
         return f"{CSI}{y};{x}H"
 
 
 class TextStyle(AnsiSequence, Enum):
-    """Create text style ANSI sequences"""
+    """Create text style ANSI sequences."""
 
     # Resets all styles and colors of text
     RESET_ALL = 0
@@ -264,7 +264,7 @@ class TextStyle(AnsiSequence, Enum):
     def __str__(self) -> str:
         """Return ANSI text style sequence instead of enum name
         This is helpful when using a TextStyle in an f-string or format() call
-        e.g. my_str = f"{TextStyle.UNDERLINE_ENABLE}hello{TextStyle.UNDERLINE_DISABLE}"
+        e.g. my_str = f"{TextStyle.UNDERLINE_ENABLE}hello{TextStyle.UNDERLINE_DISABLE}".
         """
         return f"{CSI}{self.value}m"
 
@@ -297,7 +297,7 @@ class Fg(FgColor, Enum):
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using an Fg in an f-string or format() call
-        e.g. my_str = f"{Fg.BLUE}hello{Fg.RESET}"
+        e.g. my_str = f"{Fg.BLUE}hello{Fg.RESET}".
         """
         return f"{CSI}{self.value}m"
 
@@ -330,7 +330,7 @@ class Bg(BgColor, Enum):
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using a Bg in an f-string or format() call
-        e.g. my_str = f"{Bg.BLACK}hello{Bg.RESET}"
+        e.g. my_str = f"{Bg.BLACK}hello{Bg.RESET}".
         """
         return f"{CSI}{self.value}m"
 
@@ -601,7 +601,7 @@ class EightBitFg(FgColor, Enum):
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using an EightBitFg in an f-string or format() call
-        e.g. my_str = f"{EightBitFg.SLATE_BLUE_1}hello{Fg.RESET}"
+        e.g. my_str = f"{EightBitFg.SLATE_BLUE_1}hello{Fg.RESET}".
         """
         return f"{CSI}38;5;{self.value}m"
 
@@ -872,7 +872,7 @@ class EightBitBg(BgColor, Enum):
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using an EightBitBg in an f-string or format() call
-        e.g. my_str = f"{EightBitBg.KHAKI_3}hello{Bg.RESET}"
+        e.g. my_str = f"{EightBitBg.KHAKI_3}hello{Bg.RESET}".
         """
         return f"{CSI}48;5;{self.value}m"
 
@@ -883,7 +883,7 @@ class RgbFg(FgColor):
     """
 
     def __init__(self, r: int, g: int, b: int) -> None:
-        """RgbFg initializer
+        """RgbFg initializer.
 
         :param r: integer from 0-255 for the red component of the color
         :param g: integer from 0-255 for the green component of the color
@@ -898,7 +898,7 @@ def __init__(self, r: int, g: int, b: int) -> None:
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using an RgbFg in an f-string or format() call
-        e.g. my_str = f"{RgbFg(0, 55, 100)}hello{Fg.RESET}"
+        e.g. my_str = f"{RgbFg(0, 55, 100)}hello{Fg.RESET}".
         """
         return self._sequence
 
@@ -909,7 +909,7 @@ class RgbBg(BgColor):
     """
 
     def __init__(self, r: int, g: int, b: int) -> None:
-        """RgbBg initializer
+        """RgbBg initializer.
 
         :param r: integer from 0-255 for the red component of the color
         :param g: integer from 0-255 for the green component of the color
@@ -924,7 +924,7 @@ def __init__(self, r: int, g: int, b: int) -> None:
     def __str__(self) -> str:
         """Return ANSI color sequence instead of enum name
         This is helpful when using an RgbBg in an f-string or format() call
-        e.g. my_str = f"{RgbBg(100, 255, 27)}hello{Bg.RESET}"
+        e.g. my_str = f"{RgbBg(100, 255, 27)}hello{Bg.RESET}".
         """
         return self._sequence
 

cmd2/argparse_completer.py

@@ -55,7 +55,7 @@
 
 
 def _build_hint(parser: argparse.ArgumentParser, arg_action: argparse.Action) -> str:
-    """Build tab completion hint for a given argument"""
+    """Build tab completion hint for a given argument."""
     # Check if hinting is disabled for this argument
     suppress_hint = arg_action.get_suppress_tab_hint()  # type: ignore[attr-defined]
     if suppress_hint or arg_action.help == argparse.SUPPRESS:
@@ -70,7 +70,7 @@ def _build_hint(parser: argparse.ArgumentParser, arg_action: argparse.Action) ->
 
 
 def _single_prefix_char(token: str, parser: argparse.ArgumentParser) -> bool:
-    """Returns if a token is just a single flag prefix character"""
+    """Returns if a token is just a single flag prefix character."""
     return len(token) == 1 and token[0] in parser.prefix_chars
 
 
@@ -101,7 +101,7 @@ def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
 
 
 class _ArgumentState:
-    """Keeps state of an argument being parsed"""
+    """Keeps state of an argument being parsed."""
 
     def __init__(self, arg_action: argparse.Action) -> None:
         self.action = arg_action
@@ -137,7 +137,7 @@ def __init__(self, arg_action: argparse.Action) -> None:
 class _UnfinishedFlagError(CompletionError):
     def __init__(self, flag_arg_state: _ArgumentState) -> None:
         """CompletionError which occurs when the user has not finished the current flag
-        :param flag_arg_state: information about the unfinished flag action
+        :param flag_arg_state: information about the unfinished flag action.
         """
         arg = f'{argparse._get_action_name(flag_arg_state.action)}'
         err = f'{generate_range_error(cast(int, flag_arg_state.min), cast(Union[int, float], flag_arg_state.max))}'
@@ -150,19 +150,19 @@ def __init__(self, parser: argparse.ArgumentParser, arg_action: argparse.Action)
         """CompletionError which occurs when there are no results. If hinting is allowed, then its message will
         be a hint about the argument being tab completed.
         :param parser: ArgumentParser instance which owns the action being tab completed
-        :param arg_action: action being tab completed
+        :param arg_action: action being tab completed.
         """
         # Set apply_style to False because we don't want hints to look like errors
         super().__init__(_build_hint(parser, arg_action), apply_style=False)
 
 
 class ArgparseCompleter:
-    """Automatic command line tab completion based on argparse parameters"""
+    """Automatic command line tab completion based on argparse parameters."""
 
     def __init__(
         self, parser: argparse.ArgumentParser, cmd2_app: 'Cmd', *, parent_tokens: Optional[dict[str, list[str]]] = None
     ) -> None:
-        """Create an ArgparseCompleter
+        """Create an ArgparseCompleter.
 
         :param parser: ArgumentParser instance
         :param cmd2_app: reference to the Cmd2 application that owns this ArgparseCompleter
@@ -202,7 +202,7 @@ def __init__(
     def complete(
         self, text: str, line: str, begidx: int, endidx: int, tokens: list[str], *, cmd_set: Optional[CommandSet] = None
     ) -> list[str]:
-        """Complete text using argparse metadata
+        """Complete text using argparse metadata.
 
         :param text: the string prefix we are attempting to match (all matches must begin with it)
         :param line: the current input line with leading whitespace removed
@@ -240,7 +240,7 @@ def complete(
         completed_mutex_groups: dict[argparse._MutuallyExclusiveGroup, argparse.Action] = {}
 
         def consume_argument(arg_state: _ArgumentState) -> None:
-            """Consuming token as an argument"""
+            """Consuming token as an argument."""
             arg_state.count += 1
             consumed_arg_values.setdefault(arg_state.action.dest, [])
             consumed_arg_values[arg_state.action.dest].append(token)
@@ -249,7 +249,7 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
             """Check if an argument belongs to a mutually exclusive group and either mark that group
             as complete or print an error if the group has already been completed
             :param arg_action: the action of the argument
-            :raises CompletionError: if the group is already completed
+            :raises CompletionError: if the group is already completed.
             """
             # Check if this action is in a mutually exclusive group
             for group in self._parser._mutually_exclusive_groups:
@@ -490,7 +490,7 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
         return completion_results
 
     def _complete_flags(self, text: str, line: str, begidx: int, endidx: int, matched_flags: list[str]) -> list[str]:
-        """Tab completion routine for a parsers unused flags"""
+        """Tab completion routine for a parsers unused flags."""
         # Build a list of flags that can be tab completed
         match_against = []
 
@@ -523,7 +523,7 @@ def _complete_flags(self, text: str, line: str, begidx: int, endidx: int, matche
         return matches
 
     def _format_completions(self, arg_state: _ArgumentState, completions: Union[list[str], list[CompletionItem]]) -> list[str]:
-        """Format CompletionItems into hint table"""
+        """Format CompletionItems into hint table."""
         # Nothing to do if we don't have at least 2 completions which are all CompletionItems
         if len(completions) < 2 or not all(isinstance(c, CompletionItem) for c in completions):
             return cast(list[str], completions)
@@ -605,7 +605,7 @@ def complete_subcommand_help(self, text: str, line: str, begidx: int, endidx: in
         :param begidx: the beginning index of the prefix text
         :param endidx: the ending index of the prefix text
         :param tokens: arguments passed to command/subcommand
-        :return: list of subcommand completions
+        :return: list of subcommand completions.
         """
         # If our parser has subcommands, we must examine the tokens and check if they are subcommands
         # If so, we will let the subcommand's parser handle the rest of the tokens via another ArgparseCompleter.
@@ -626,7 +626,7 @@ def complete_subcommand_help(self, text: str, line: str, begidx: int, endidx: in
     def format_help(self, tokens: list[str]) -> str:
         """Supports cmd2's help command in the retrieval of help text
         :param tokens: arguments passed to help command
-        :return: help text of the command being queried
+        :return: help text of the command being queried.
         """
         # If our parser has subcommands, we must examine the tokens and check if they are subcommands
         # If so, we will let the subcommand's parser handle the rest of the tokens via another ArgparseCompleter.
@@ -654,7 +654,7 @@ def _complete_arg(
     ) -> list[str]:
         """Tab completion routine for an argparse argument
         :return: list of completions
-        :raises CompletionError: if the completer or choices function this calls raises one
+        :raises CompletionError: if the completer or choices function this calls raises one.
         """
         # Check if the arg provides choices to the user
         arg_choices: Union[list[str], ChoicesCallable]