Updated main code to use f-strings

Author: kmvanbrunt

cmd2/ansi.py

@@ -78,7 +78,7 @@ def __str__(self) -> str:
         """
         Return ANSI color sequence instead of enum name
         This is helpful when using a ColorBase in an f-string or format() call
-        e.g. my_str = "{}hello{}".format(fg.blue, fg.reset)
+        e.g. my_str = f"{fg.blue}hello{fg.reset}"
         """
         return str(self.value)
 
@@ -244,7 +244,7 @@ def fg_lookup(fg_name: Union[str, fg]) -> str:
     try:
         ansi_escape = fg[fg_name.lower()].value
     except KeyError:
-        raise ValueError('Foreground color {!r} does not exist; must be one of: {}'.format(fg_name, fg.colors()))
+        raise ValueError(f"Foreground color '{fg_name}' does not exist; must be one of: {fg.colors()}")
     return str(ansi_escape)
 
 
@@ -262,7 +262,7 @@ def bg_lookup(bg_name: Union[str, bg]) -> str:
     try:
         ansi_escape = bg[bg_name.lower()].value
     except KeyError:
-        raise ValueError('Background color {!r} does not exist; must be one of: {}'.format(bg_name, bg.colors()))
+        raise ValueError(f"Background color '{bg_name}' does not exist; must be one of: {bg.colors()}")
     return str(ansi_escape)
 
 
@@ -274,14 +274,14 @@ def style(
     bg: Union[str, bg] = '',
     bold: bool = False,
     dim: bool = False,
-    underline: bool = False
+    underline: bool = False,
 ) -> str:
     """
     Apply ANSI colors and/or styles to a string and return it.
     The styling is self contained which means that at the end of the string reset code(s) are issued
     to undo whatever styling was done at the beginning.
 
-    :param text: Any object compatible with str.format()
+    :param text: text to format (anything convertible to a str)
     :param fg: foreground color. Relies on `fg_lookup()` to retrieve ANSI escape based on name or enum.
                Defaults to no color.
     :param bg: background color. Relies on `bg_lookup()` to retrieve ANSI escape based on name or enum.
@@ -298,7 +298,7 @@ def style(
     removals: List[str] = []
 
     # Convert the text object into a string if it isn't already one
-    text_formatted = "{}".format(text)
+    text_formatted = str(text)
 
     # Process the style settings
     if fg:

cmd2/argparse_custom.py

@@ -256,18 +256,16 @@ def generate_range_error(range_min: int, range_max: Union[int, float]) -> str:
     err_str = "expected "
 
     if range_max == constants.INFINITY:
-        err_str += "at least {} argument".format(range_min)
-
-        if range_min != 1:
-            err_str += "s"
+        plural = '' if range_min == 1 else 's'
+        err_str += f"at least {range_min}"
     else:
+        plural = '' if range_max == 1 else 's'
         if range_min == range_max:
-            err_str += "{} argument".format(range_min)
+            err_str += f"{range_min}"
         else:
-            err_str += "{} to {} argument".format(range_min, range_max)
+            err_str += f"{range_min} to {range_max}"
 
-        if range_max != 1:
-            err_str += "s"
+    err_str += f" argument{plural}"
 
     return err_str
 
@@ -600,7 +598,7 @@ def _get_nargs_pattern_wrapper(self: argparse.ArgumentParser, action: argparse.A
         else:
             range_max = nargs_range[1]
 
-        nargs_pattern = '(-*A{{{},{}}}-*)'.format(nargs_range[0], range_max)
+        nargs_pattern = f'(-*A{{{nargs_range[0]},{range_max}}}-*)'
 
         # if this is an optional action, -- is not allowed
         if action.option_strings:
@@ -881,9 +879,9 @@ def _format_args(self, action: argparse.Action, default_metavar: Union[str, Tupl
         nargs_range = getattr(action, ATTR_NARGS_RANGE, None)
         if nargs_range is not None:
             if nargs_range[1] == constants.INFINITY:
-                range_str = '{}+'.format(nargs_range[0])
+                range_str = f'{nargs_range[0]}+'
             else:
-                range_str = '{}..{}'.format(nargs_range[0], nargs_range[1])
+                range_str = f'{nargs_range[0]}..{nargs_range[1]}'
 
             return '{}{{{}}}'.format('%s' % metavar_formatter(1), range_str)
 
@@ -960,7 +958,7 @@ def error(self, message: str) -> NoReturn:
 
         self.print_usage(sys.stderr)
         formatted_message = ansi.style_error(formatted_message)
-        self.exit(2, '{}\n\n'.format(formatted_message))
+        self.exit(2, f'{formatted_message}\n\n')
 
     # noinspection PyProtectedMember
     def format_help(self) -> str:

cmd2/cmd2.py

@@ -298,7 +298,7 @@ def with_argparser(
     >>>     @cmd2.with_argparser(parser, preserve_quotes=True)
     >>>     def do_argprint(self, args):
     >>>         "Print the options and argument list this options command was called with."
-    >>>         self.poutput('args: {!r}'.format(args))
+    >>>         self.poutput(f'args: {args!r}')
 
     :Example with unknown args:
 
@@ -311,8 +311,8 @@ def with_argparser(
     >>>     @cmd2.with_argparser(parser, with_unknown_args=True)
     >>>     def do_argprint(self, args, unknown):
     >>>         "Print the options and argument list this options command was called with."
-    >>>         self.poutput('args: {!r}'.format(args))
-    >>>         self.poutput('unknowns: {}'.format(unknown))
+    >>>         self.poutput(f'args: {args!r}')
+    >>>         self.poutput(f'unknowns: {unknown}')
 
     """
     import functools

cmd2/decorators.py

@@ -167,7 +167,7 @@ def command_and_args(self) -> str:
         excluded, as are any command terminators.
         """
         if self.command and self.args:
-            rtn = '{} {}'.format(self.command, self.args)
+            rtn = f'{self.command} {self.args}'
         elif self.command:
             # there were no arguments to the command
             rtn = self.command
@@ -286,7 +286,7 @@ def __init__(
         # join them up with a pipe
         second_group = '|'.join(second_group_items)
         # build the regular expression
-        expr = r'\A\s*(\S*?)({})'.format(second_group)
+        expr = rf'\A\s*(\S*?)({second_group})'
         self._command_pattern = re.compile(expr)
 
     def is_valid_command(self, word: str, *, is_subcommand: bool = False) -> Tuple[bool, str]:
@@ -306,12 +306,12 @@ def is_valid_command(self, word: str, *, is_subcommand: bool = False) -> Tuple[b
             checkit = '>'
             valid, errmsg = statement_parser.is_valid_command(checkit)
             if not valid:
-                errmsg = "alias: {}".format(errmsg)
+                errmsg = f"alias: {errmsg}"
         """
         valid = False
 
         if not isinstance(word, str):
-            return False, 'must be a string. Received {} instead'.format(str(type(word)))  # type: ignore[unreachable]
+            return False, f'must be a string. Received {str(type(word))} instead'  # type: ignore[unreachable]
 
         if not word:
             return False, 'cannot be an empty string'

cmd2/parsing.py

@@ -66,7 +66,7 @@ def __init__(
         header_vert_align: VerticalAlignment = VerticalAlignment.BOTTOM,
         data_horiz_align: HorizontalAlignment = HorizontalAlignment.LEFT,
         data_vert_align: VerticalAlignment = VerticalAlignment.TOP,
-        max_data_lines: Union[int, float] = constants.INFINITY
+        max_data_lines: Union[int, float] = constants.INFINITY,
     ) -> None:
         """
         Column initializer
@@ -408,7 +408,7 @@ def generate_row(
         fill_char: str = SPACE,
         pre_line: str = EMPTY,
         inter_cell: str = (2 * SPACE),
-        post_line: str = EMPTY
+        post_line: str = EMPTY,
     ) -> str:
         """
         Generate a header or data table row
@@ -462,7 +462,7 @@ def __init__(self) -> None:
         validation_dict = {'fill_char': fill_char, 'pre_line': pre_line, 'inter_cell': inter_cell, 'post_line': post_line}
         for key, val in validation_dict.items():
             if ansi.style_aware_wcswidth(val) == -1:
-                raise (ValueError("{} contains an unprintable character".format(key)))
+                raise ValueError(f"{key} contains an unprintable character")
 
         # Number of lines this row uses
         total_lines = 0
@@ -556,7 +556,7 @@ def __init__(self, cols: Sequence[Column], *, tab_width: int = 4, divider_char:
 
             divider_char_width = ansi.style_aware_wcswidth(divider_char)
             if divider_char_width == -1:
-                raise (ValueError("Divider character is an unprintable character"))
+                raise ValueError("Divider character is an unprintable character")
 
         super().__init__(cols, tab_width=tab_width)
         self.divider_char = divider_char
@@ -855,7 +855,7 @@ def __init__(
         column_borders: bool = True,
         padding: int = 1,
         bg_odd: Optional[ansi.bg] = None,
-        bg_even: Optional[ansi.bg] = ansi.bg.bright_black
+        bg_even: Optional[ansi.bg] = ansi.bg.bright_black,
     ) -> None:
         """
         AlternatingTable initializer

cmd2/table_creator.py

@@ -100,9 +100,7 @@ def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
                 try:
                     line = next(transcript)
                 except StopIteration as exc:
-                    msg = 'Transcript broke off while reading command beginning at line {} with\n{}'.format(
-                        line_num, command_parts[0]
-                    )
+                    msg = f'Transcript broke off while reading command beginning at line {line_num} with\n{command_parts[0]}'
                     raise StopIteration(msg) from exc
                 line_num += 1
             command = ''.join(command_parts)
@@ -112,9 +110,7 @@ def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
             stop_msg = 'Command indicated application should quit, but more commands in transcript'
             # Read the expected result from transcript
             if ansi.strip_style(line).startswith(self.cmdapp.visible_prompt):
-                message = '\nFile {}, line {}\nCommand was:\n{}\nExpected: (nothing)\nGot:\n{}\n'.format(
-                    fname, line_num, command, result
-                )
+                message = f'\nFile {fname}, line {line_num}\nCommand was:\n{command}\nExpected: (nothing)\nGot:\n{result}\n'
                 self.assertTrue(not (result.strip()), message)
                 # If the command signaled the application to quit there should be no more commands
                 self.assertFalse(stop, stop_msg)
@@ -136,9 +132,7 @@ def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
             # transform the expected text into a valid regular expression
             expected = ''.join(expected_parts)
             expected = self._transform_transcript_expected(expected)
-            message = '\nFile {}, line {}\nCommand was:\n{}\nExpected:\n{}\nGot:\n{}\n'.format(
-                fname, line_num, command, expected, result
-            )
+            message = f'\nFile {fname}, line {line_num}\nCommand was:\n{command}\nExpected:\n{expected}\nGot:\n{result}\n'
             self.assertTrue(re.match(expected, result, re.MULTILINE | re.DOTALL), message)
 
     def _transform_transcript_expected(self, s: str) -> str:

cmd2/transcript.py

@@ -474,7 +474,7 @@ def write(self, s: str) -> None:
         :param s: String to write to the stream
         """
         if not isinstance(s, str):
-            raise TypeError('write() argument must be str, not {}'.format(type(s)))
+            raise TypeError(f'write() argument must be str, not {type(s)}')
 
         if not self.pause_storage:
             self.buffer.byte_buf += s.encode(encoding=self.encoding, errors=self.errors)
@@ -554,7 +554,7 @@ def __init__(self, std_sim_instance: StdSim) -> None:
     def write(self, b: bytes) -> None:
         """Add bytes to internal bytes buffer and if echo is True, echo contents to inner stream."""
         if not isinstance(b, bytes):
-            raise TypeError('a bytes-like object is required, not {}'.format(type(b)))
+            raise TypeError(f'a bytes-like object is required, not {type(b)}')
         if not self.std_sim_instance.pause_storage:
             self.byte_buf += b
         if self.std_sim_instance.echo:

cmd2/utils.py

@@ -704,7 +704,7 @@ def _expected_no_editor_error():
 
     expected_text = normalize(
         """
-EXCEPTION of type '{}' occurred with message: 'Please use 'set editor' to specify your text editing program of choice.'
+EXCEPTION of type '{}' occurred with message: Please use 'set editor' to specify your text editing program of choice.
 To enable full traceback, run the following command: 'set debug true'
 """.format(
             expected_exception
@@ -1986,7 +1986,7 @@ def test_macro_usage_with_missing_args(base_app):
 
     # Run the macro
     out, err = run_cmd(base_app, 'fake arg1')
-    assert "expects at least 2 argument(s)" in err[0]
+    assert "expects at least 2 arguments" in err[0]
 
 
 def test_macro_usage_with_exta_args(base_app):
@@ -2018,7 +2018,7 @@ def test_macro_create_with_unicode_numbered_arg(base_app):
 
     # Run the macro
     out, err = run_cmd(base_app, 'fake')
-    assert "expects at least 1 argument(s)" in err[0]
+    assert "expects at least 1 argument" in err[0]
 
 
 def test_macro_create_with_missing_unicode_arg_nums(base_app):