Do a bunch of automated refactoring using ruff UP ruleset to do things like replace .format() with f-strings

Author: tleonhardt

cmd2/argparse_completer.py

@@ -12,7 +12,6 @@
 from typing import (
     TYPE_CHECKING,
     Optional,
-    Type,
     Union,
     cast,
 )
@@ -143,11 +142,9 @@ 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
         """
-        error = "Error: argument {}: {} ({} entered)".format(
-            argparse._get_action_name(flag_arg_state.action),
-            generate_range_error(cast(int, flag_arg_state.min), cast(Union[int, float], flag_arg_state.max)),
-            flag_arg_state.count,
-        )
+        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))}'
+        error = f"Error: argument {arg}: {err} ({flag_arg_state.count} entered)"
         super().__init__(error)
 
 
@@ -272,9 +269,9 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
                         if arg_action == completer_action:
                             return
 
-                        error = "Error: argument {}: not allowed with argument {}".format(
-                            argparse._get_action_name(arg_action), argparse._get_action_name(completer_action)
-                        )
+                        arg_str = f'{argparse._get_action_name(arg_action)}'
+                        completer_str = f'{argparse._get_action_name(completer_action)}'
+                        error = f"Error: argument {arg_str}: not allowed with argument {completer_str}"
                         raise CompletionError(error)
 
                     # Mark that this action completed the group
@@ -766,10 +763,10 @@ def _complete_arg(
 
 
 # The default ArgparseCompleter class for a cmd2 app
-DEFAULT_AP_COMPLETER: Type[ArgparseCompleter] = ArgparseCompleter
+DEFAULT_AP_COMPLETER: type[ArgparseCompleter] = ArgparseCompleter
 
 
-def set_default_ap_completer_type(completer_type: Type[ArgparseCompleter]) -> None:
+def set_default_ap_completer_type(completer_type: type[ArgparseCompleter]) -> None:
     """
     Set the default ArgparseCompleter class for a cmd2 app.
 

examples/modular_commands/commandset_complex.py

@@ -21,7 +21,7 @@ def do_banana(self, statement: cmd2.Statement):
 
     @cmd2.with_argparser(cranberry_parser, with_unknown_args=True)
     def do_cranberry(self, ns: argparse.Namespace, unknown: list[str]):
-        self._cmd.poutput('Cranberry {}!!'.format(ns.arg1))
+        self._cmd.poutput(f'Cranberry {ns.arg1}!!')
         if unknown and len(unknown):
             self._cmd.poutput('Unknown: ' + ', '.join(['{}'] * len(unknown)).format(*unknown))
         self._cmd.last_result = {'arg1': ns.arg1, 'unknown': unknown}
@@ -33,7 +33,7 @@ def help_cranberry(self):
     @cmd2.with_category('Also Alone')
     def do_durian(self, args: list[str]):
         """Durian Command"""
-        self._cmd.poutput('{} Arguments: '.format(len(args)))
+        self._cmd.poutput(f'{len(args)} Arguments: ')
         self._cmd.poutput(', '.join(['{}'] * len(args)).format(*args))
 
     def complete_durian(self, text: str, line: str, begidx: int, endidx: int) -> list[str]:
@@ -45,4 +45,4 @@ def complete_durian(self, text: str, line: str, begidx: int, endidx: int) -> lis
     @cmd2.with_category('Alone')
     @cmd2.with_argparser(elderberry_parser)
     def do_elderberry(self, ns: argparse.Namespace):
-        self._cmd.poutput('Elderberry {}!!'.format(ns.arg1))
+        self._cmd.poutput(f'Elderberry {ns.arg1}!!')

examples/scripts/conditional.py

@@ -14,36 +14,36 @@
 
 if len(sys.argv) > 1:
     directory = sys.argv[1]
-    print('Using specified directory: {!r}'.format(directory))
+    print(f'Using specified directory: {directory!r}')
 else:
     directory = 'foobar'
-    print('Using default directory: {!r}'.format(directory))
+    print(f'Using default directory: {directory!r}')
 
 # Keep track of where we stared
 original_dir = os.getcwd()
 
 # Try to change to the specified directory
-result = app('cd {}'.format(directory))
+result = app(f'cd {directory}')
 
 # Conditionally do something based on the results of the last command
 if result:
     print(f"STDOUT: {result.stdout}\n")
     print(f"STDERR: {result.stderr}\n")
 
-    print('\nContents of directory {!r}:'.format(directory))
+    print(f'\nContents of directory {directory!r}:')
     result = app('dir -l')
 
     print(f"STDOUT: {result.stdout}\n")
     print(f"STDERR: {result.stderr}\n")
 
-    print('{}\n'.format(result.data))
+    print(f'{result.data}\n')
 
     # Change back to where we were
-    print('Changing back to original directory: {!r}'.format(original_dir))
-    app('cd {}'.format(original_dir))
+    print(f'Changing back to original directory: {original_dir!r}')
+    app(f'cd {original_dir}')
 else:
     # cd command failed, print a warning
-    print('Failed to change directory to {!r}'.format(directory))
+    print(f'Failed to change directory to {directory!r}')
 
     print(f"STDOUT: {result.stdout}\n")
     print(f"STDERR: {result.stderr}\n")

examples/scripts/save_help_text.py

@@ -43,10 +43,10 @@ def add_help_to_file(item: str, outfile: TextIO, is_command: bool) -> None:
     else:
         label = "TOPIC"
 
-    header = '{}\n{}: {}\n{}\n'.format(ASTERISKS, label, item, ASTERISKS)
+    header = f'{ASTERISKS}\n{label}: {item}\n{ASTERISKS}\n'
     outfile.write(header)
 
-    result = app('help {}'.format(item))
+    result = app(f'help {item}')
     outfile.write(result.stdout)
 
 
@@ -60,19 +60,19 @@ def main() -> None:
 
     # Make sure the user passed in an output file
     if len(sys.argv) != 2:
-        print("Usage: {} <output_file>".format(os.path.basename(sys.argv[0])))
+        print(f"Usage: {os.path.basename(sys.argv[0])} <output_file>")
         return
 
     # Open the output file
     outfile_path = os.path.expanduser(sys.argv[1])
     try:
         outfile = open(outfile_path, 'w')
     except OSError as e:
-        print("Error opening {} because: {}".format(outfile_path, e))
+        print(f"Error opening {outfile_path} because: {e}")
         return
 
     # Write the help summary
-    header = '{0}\nSUMMARY\n{0}\n'.format(ASTERISKS)
+    header = f'{ASTERISKS}\nSUMMARY\n{ASTERISKS}\n'
     outfile.write(header)
 
     result = app('help -v')
@@ -91,11 +91,11 @@ def main() -> None:
         if is_command:
             # Add any subcommands
             for subcmd in get_sub_commands(getattr(self.cmd_func(item), 'argparser', None)):
-                full_cmd = '{} {}'.format(item, subcmd)
+                full_cmd = f'{item} {subcmd}'
                 add_help_to_file(full_cmd, outfile, is_command)
 
     outfile.close()
-    print("Output written to {}".format(outfile_path))
+    print(f"Output written to {outfile_path}")
 
 
 # Run main function

tasks.py

@@ -30,7 +30,7 @@ def rmrf(items, verbose=True):
 
     for item in items:
         if verbose:
-            print("Removing {}".format(item))
+            print(f"Removing {item}")
         shutil.rmtree(item, ignore_errors=True)
         # rmtree doesn't remove bare files
         try:
@@ -270,8 +270,8 @@ def tag(context, name, message=''):
     """Add a Git tag and push it to origin"""
     # If a tag was provided on the command-line, then add a Git tag and push it to origin
     if name:
-        context.run('git tag -a {} -m {!r}'.format(name, message))
-        context.run('git push origin {}'.format(name))
+        context.run(f'git tag -a {name} -m {message!r}')
+        context.run(f'git push origin {name}')
 
 
 namespace.add_task(tag)
@@ -288,10 +288,10 @@ def validatetag(context):
     ver_regex = re.compile(r'(\d+)\.(\d+)\.(\d+)')
     match = ver_regex.fullmatch(git_tag)
     if match is None:
-        print('Tag {!r} does not appear to be a valid version number'.format(git_tag))
+        print(f'Tag {git_tag!r} does not appear to be a valid version number')
         sys.exit(-1)
     else:
-        print('Tag {!r} appears to be a valid version number'.format(git_tag))
+        print(f'Tag {git_tag!r} appears to be a valid version number')
 
 
 namespace.add_task(validatetag)

tests/pyscript/environment.py

@@ -5,16 +5,16 @@
 app.cmd_echo = True
 
 if __name__ != '__main__':
-    print("Error: __name__ is: {}".format(__name__))
+    print(f"Error: __name__ is: {__name__}")
     quit()
 
 if __file__ != sys.argv[0]:
-    print("Error: __file__ is: {}".format(__file__))
+    print(f"Error: __file__ is: {__file__}")
     quit()
 
 our_dir = os.path.dirname(os.path.abspath(__file__))
 if our_dir != sys.path[0]:
-    print("Error: our_dir is: {}".format(our_dir))
+    print(f"Error: our_dir is: {our_dir}")
     quit()
 
 print("PASSED")

tests/test_argparse.py

@@ -70,7 +70,7 @@ def do_tag(self, args):
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser(), ns_provider=namespace_provider)
     def do_test_argparse_ns(self, args):
-        self.stdout.write('{}'.format(args.custom_stuff))
+        self.stdout.write(f'{args.custom_stuff}')
 
     @cmd2.with_argument_list
     def do_arglist(self, arglist, *, keyword_arg: Optional[str] = None):
@@ -84,7 +84,7 @@ def do_arglist(self, arglist, *, keyword_arg: Optional[str] = None):
 
     @cmd2.with_argument_list(preserve_quotes=True)
     def do_preservelist(self, arglist):
-        self.stdout.write('{}'.format(arglist))
+        self.stdout.write(f'{arglist}')
 
     @classmethod
     def _speak_parser_builder(cls) -> cmd2.Cmd2ArgumentParser:
@@ -120,7 +120,7 @@ def do_test_argparse_with_list_quotes(self, args, extra):
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser(), ns_provider=namespace_provider, with_unknown_args=True)
     def do_test_argparse_with_list_ns(self, args, extra):
-        self.stdout.write('{}'.format(args.custom_stuff))
+        self.stdout.write(f'{args.custom_stuff}')
 
 
 @pytest.fixture