Enable ruff N ruleset for pep8 naming conventions

Author: tleonhardt

cmd2/argparse_custom.py

@@ -883,7 +883,7 @@ def _match_argument_wrapper(self: argparse.ArgumentParser, action: argparse.Acti
 ATTR_AP_COMPLETER_TYPE = 'ap_completer_type'
 
 
-def _ArgumentParser_get_ap_completer_type(self: argparse.ArgumentParser) -> Optional[type['ArgparseCompleter']]:
+def _ArgumentParser_get_ap_completer_type(self: argparse.ArgumentParser) -> Optional[type['ArgparseCompleter']]:  # noqa: N802
     """Get the ap_completer_type attribute of an argparse ArgumentParser.
 
     This function is added by cmd2 as a method called ``get_ap_completer_type()`` to ``argparse.ArgumentParser`` class.
@@ -899,7 +899,7 @@ def _ArgumentParser_get_ap_completer_type(self: argparse.ArgumentParser) -> Opti
 setattr(argparse.ArgumentParser, 'get_ap_completer_type', _ArgumentParser_get_ap_completer_type)
 
 
-def _ArgumentParser_set_ap_completer_type(self: argparse.ArgumentParser, ap_completer_type: type['ArgparseCompleter']) -> None:
+def _ArgumentParser_set_ap_completer_type(self: argparse.ArgumentParser, ap_completer_type: type['ArgparseCompleter']) -> None:  # noqa: N802
     """Set the ap_completer_type attribute of an argparse ArgumentParser.
 
     This function is added by cmd2 as a method called ``set_ap_completer_type()`` to ``argparse.ArgumentParser`` class.
@@ -918,7 +918,7 @@ def _ArgumentParser_set_ap_completer_type(self: argparse.ArgumentParser, ap_comp
 ############################################################################################################
 # Patch ArgumentParser._check_value to support CompletionItems as choices
 ############################################################################################################
-def _ArgumentParser_check_value(self: argparse.ArgumentParser, action: argparse.Action, value: Any) -> None:
+def _ArgumentParser_check_value(self: argparse.ArgumentParser, action: argparse.Action, value: Any) -> None:  # noqa: N802
     """Custom override of ArgumentParser._check_value that supports CompletionItems as choices.
     When evaluating choices, input is compared to CompletionItem.orig_value instead of the
     CompletionItem instance.
@@ -950,7 +950,7 @@ def _ArgumentParser_check_value(self: argparse.ArgumentParser, action: argparse.
 ############################################################################################################
 
 
-def _SubParsersAction_remove_parser(self: argparse._SubParsersAction, name: str) -> None:  # type: ignore[type-arg]
+def _SubParsersAction_remove_parser(self: argparse._SubParsersAction, name: str) -> None:  # type: ignore[type-arg]  # noqa: N802
     """Removes a sub-parser from a sub-parsers group. Used to remove subcommands from a parser.
 
     This function is added by cmd2 as a method called ``remove_parser()`` to ``argparse._SubParsersAction`` class.

cmd2/cmd2.py

@@ -1973,7 +1973,7 @@ def _determine_ap_completer_type(parser: argparse.ArgumentParser) -> type[argpar
         :param parser: the parser to examine
         :return: type of ArgparseCompleter
         """
-        Completer = Optional[type[argparse_completer.ArgparseCompleter]]
+        Completer = Optional[type[argparse_completer.ArgparseCompleter]]  # noqa: N806
         completer_type: Completer = parser.get_ap_completer_type()  # type: ignore[attr-defined]
 
         if completer_type is None:
@@ -4528,7 +4528,7 @@ def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
 
         # Detect whether IPython is installed
         try:
-            import traitlets.config.loader as TraitletsLoader  # type: ignore[import]
+            import traitlets.config.loader as traitlets_loader  # type: ignore[import]
 
             # Allow users to install ipython from a cmd2 prompt when needed and still have ipy command work
             try:
@@ -4569,7 +4569,7 @@ def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
                 local_vars['self'] = self
 
             # Configure IPython
-            config = TraitletsLoader.Config()
+            config = traitlets_loader.Config()
             config.InteractiveShell.banner2 = (
                 'Entering an IPython shell. Type exit, quit, or Ctrl-D to exit.\n'
                 f'Run CLI commands with: {self.py_bridge_name}("command ...")\n'

cmd2/exceptions.py

@@ -7,7 +7,7 @@
 ############################################################################################################
 
 
-class SkipPostcommandHooks(Exception):
+class SkipPostcommandHooks(Exception):  # noqa: N818
     """Custom exception class for when a command has a failure bad enough to skip post command
     hooks, but not bad enough to print the exception to the user.
     """
@@ -50,7 +50,7 @@ def __init__(self, *args: Any, apply_style: bool = True) -> None:
         super().__init__(*args)
 
 
-class PassThroughException(Exception):
+class PassThroughException(Exception):  # noqa: N818
     """Normally all unhandled exceptions raised during commands get printed to the user.
     This class is used to wrap an exception that should be raised instead of printed.
     """
@@ -76,7 +76,7 @@ class EmbeddedConsoleExit(SystemExit):
     """Custom exception class for use with the py command."""
 
 
-class EmptyStatement(Exception):
+class EmptyStatement(Exception):  # noqa: N818
     """Custom exception class for handling behavior when the user just presses <Enter>."""
 
 

cmd2/rl_utils.py

@@ -72,24 +72,24 @@ def enable_win_vt100(handle: HANDLE) -> bool:
             :param handle: the handle on which to enable vt100
             :return: True if vt100 characters are enabled for the handle.
             """
-            ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+            enable_virtual_terminal_processing = 0x0004
 
             # Get the current mode for this handle in the console
             cur_mode = DWORD(0)
             readline.rl.console.GetConsoleMode(handle, byref(cur_mode))
 
-            retVal = False
+            ret_val = False
 
             # Check if ENABLE_VIRTUAL_TERMINAL_PROCESSING is already enabled
-            if (cur_mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0:
-                retVal = True
+            if (cur_mode.value & enable_virtual_terminal_processing) != 0:
+                ret_val = True
 
-            elif readline.rl.console.SetConsoleMode(handle, cur_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING):
+            elif readline.rl.console.SetConsoleMode(handle, cur_mode.value | enable_virtual_terminal_processing):
                 # Restore the original mode when we exit
                 atexit.register(readline.rl.console.SetConsoleMode, handle, cur_mode)
-                retVal = True
+                ret_val = True
 
-            return retVal
+            return ret_val
 
         # Enable VT100 sequences for stdout and stderr
         STD_OUT_HANDLE = -11
@@ -273,10 +273,10 @@ def rl_in_search_mode() -> bool:  # pragma: no cover
         # GNU Readline defines constants that we can use to determine if in search mode.
         #     RL_STATE_ISEARCH    0x0000080
         #     RL_STATE_NSEARCH    0x0000100
-        IN_SEARCH_MODE = 0x0000180
+        in_search_mode = 0x0000180
 
         readline_state = ctypes.c_int.in_dll(readline_lib, "rl_readline_state").value
-        return bool(IN_SEARCH_MODE & readline_state)
+        return bool(in_search_mode & readline_state)
     if rl_type == RlType.PYREADLINE:
         from pyreadline3.modes.emacs import (  # type: ignore[import]
             EmacsMode,

cmd2/transcript.py

@@ -43,7 +43,7 @@ class Cmd2TestCase(unittest.TestCase):
 
     def setUp(self) -> None:
         if self.cmdapp:
-            self._fetchTranscripts()
+            self._fetch_transcripts()
 
             # Trap stdout
             self._orig_stdout = self.cmdapp.stdout
@@ -54,13 +54,13 @@ def tearDown(self) -> None:
             # Restore stdout
             self.cmdapp.stdout = self._orig_stdout
 
-    def runTest(self) -> None:  # was testall
+    def runTest(self) -> None:  # was testall  # noqa: N802
         if self.cmdapp:
             its = sorted(self.transcripts.items())
             for fname, transcript in its:
                 self._test_transcript(fname, transcript)
 
-    def _fetchTranscripts(self) -> None:
+    def _fetch_transcripts(self) -> None:
         self.transcripts = {}
         testfiles = cast(list[str], getattr(self.cmdapp, 'testfiles', []))
         for fname in testfiles:

examples/migrating.py

@@ -17,7 +17,7 @@ def do_exit(self, line) -> bool:
         """Exit the application."""
         return True
 
-    do_EOF = do_exit
+    do_EOF = do_exit  # noqa: N815
     do_quit = do_exit
 
     def do_speak(self, line) -> None:

examples/override_parser.py

@@ -12,9 +12,7 @@
 
 # Next import from cmd2. It will import your module just before the cmd2.Cmd class file is imported
 # and therefore override the parser class it uses on its commands.
-from cmd2 import (
-    cmd2,
-)
+from cmd2 import cmd2  # noqa: E402
 
 if __name__ == '__main__':
     import sys

examples/unicode_commands.py

@@ -13,11 +13,11 @@ def __init__(self) -> None:
         super().__init__()
         self.intro = 'Welcome the Unicode example app. Note the full Unicode support:  😇 💩'
 
-    def do_𝛑print(self, _) -> None:
+    def do_𝛑print(self, _) -> None:  # noqa: PLC2401
         """This command prints 𝛑 to 5 decimal places."""
         self.poutput(f"𝛑 = {math.pi:.6}")
 
-    def do_你好(self, arg) -> None:
+    def do_你好(self, arg) -> None:  # noqa: N802, PLC2401
         """This command says hello in Chinese (Mandarin)."""
         self.poutput("你好 " + arg)
 

plugins/ext_test/tasks.py

@@ -48,15 +48,15 @@ def rmrf(items, verbose=True):
 @invoke.task
 def pytest(context, junit=False, pty=True, append_cov=False):
     """Run tests and code coverage using pytest"""
-    ROOT_PATH = TASK_ROOT.parent.parent
+    root_path = TASK_ROOT.parent.parent
 
-    with context.cd(str(ROOT_PATH)):
+    with context.cd(str(root_path)):
         command_str = 'pytest --cov=cmd2_ext_test --cov-report=term --cov-report=html'
         if append_cov:
             command_str += ' --cov-append'
         if junit:
             command_str += ' --junitxml=junit/test-results.xml'
-        command_str += ' ' + str((TASK_ROOT / 'tests').relative_to(ROOT_PATH))
+        command_str += ' ' + str((TASK_ROOT / 'tests').relative_to(root_path))
         context.run(command_str, pty=pty)
 
 

plugins/template/tasks.py

@@ -41,15 +41,15 @@ def rmrf(items, verbose=True) -> None:
 @invoke.task
 def pytest(context, junit=False, pty=True, append_cov=False) -> None:
     """Run tests and code coverage using pytest."""
-    ROOT_PATH = TASK_ROOT.parent.parent
+    root_path = TASK_ROOT.parent.parent
 
-    with context.cd(str(ROOT_PATH)):
+    with context.cd(str(root_path)):
         command_str = 'pytest --cov=cmd2_myplugin --cov-report=term --cov-report=html'
         if append_cov:
             command_str += ' --cov-append'
         if junit:
             command_str += ' --junitxml=junit/test-results.xml'
-        command_str += ' ' + str((TASK_ROOT / 'tests').relative_to(ROOT_PATH))
+        command_str += ' ' + str((TASK_ROOT / 'tests').relative_to(root_path))
         context.run(command_str, pty=pty)
 
 

pyproject.toml

@@ -189,7 +189,7 @@ select = [
     "INT",  # flake8-gettext (warnings that only apply when you are internationalizing your strings)
     "ISC",  # flake8-implicit-str-concat (warnings related to implicit vs explicit string concatenation)
     "LOG",  # flake8-logging (warn about potential logger issues, but very pedantic)
-    # "N", # pep8-naming (force idiomatic naming for classes, functions/methods, and variables/arguments)
+    "N",    # pep8-naming (force idiomatic naming for classes, functions/methods, and variables/arguments)
     # "NPY",  # NumPy specific rules
     # "PD",   # pandas-vet (Pandas specific rules)
     "PERF", # Perflint (warn about performance issues)
@@ -260,6 +260,10 @@ per-file-ignores."cmd2/argparse_custom.py" = [
     "UP031", # Use format specifiers instead of percent format (auto fix is unsafe)
 ]
 
+per-file-ignores."cmd2/ansi.py" = [
+    "N802", # Function names should be lowercase for things like Curor.UP
+]
+
 per-file-ignores."examples/*.py" = [
     "ANN",     # Ignore all type annotation rules in examples folder
     "D",       # Ignore all pydocstyle rules in examples folder
@@ -268,18 +272,10 @@ per-file-ignores."examples/*.py" = [
     "S",       # Ignore all Security rules in examples folder
 ]
 
-per-file-ignores."examples/override_parser.py" = [
-    "E402", # Module level import not at top of file
-]
-
 per-file-ignores."examples/scripts/*.py" = [
     "F821", # Undefined name `app`
 ]
 
-per-file-ignores."examples/unicode_commands.py" = [
-    "PLC2401", # non-ASCII characters in function names
-]
-
 per-file-ignores."plugins/*.py" = [
     "ANN",    # Ignore all type annotation rules in test folders
     "D",      # Ignore all pydocstyle rules in test folders
@@ -296,10 +292,6 @@ per-file-ignores."tests/*.py" = [
     "SLF",  # Ignore all warnings about private or protected member access in test folders
 ]
 
-per-file-ignores."tests/test_argparse.py" = [
-    "PLW2901", # loop variable overwritten inside loop
-]
-
 per-file-ignores."tests/pyscript/*.py" = [
     "F821",   # Undefined name `app`
     "INP001", # Module is part of an implicit namespace
@@ -312,10 +304,6 @@ per-file-ignores."tests_isolated/*.py" = [
     "SLF", # Ignore all warnings about private or protected member access in test folders
 ]
 
-per-file-ignores."tests_isolated/test_commandset/test_commandset.py" = [
-    "PLW0603", # Using the global statement to update {name} is discouraged
-]
-
 
 [tool.ruff.format]
 # Like Black, use double quotes for strings.

tests/test_argparse.py

@@ -41,13 +41,14 @@ def do_say(self, args, *, keyword_arg: Optional[str] = None) -> None:
         """
         words = []
         for word in args.words:
+            modified_word = word
             if word is None:
-                word = ''
+                modified_word = ''
             if args.piglatin:
-                word = f'{word[1:]}{word[0]}ay'
+                modified_word = f'{word[1:]}{word[0]}ay'
             if args.shout:
-                word = word.upper()
-            words.append(word)
+                modified_word = word.upper()
+            words.append(modified_word)
         repetitions = args.repeat or 1
         for i in range(min(repetitions, self.maxrepeats)):
             self.stdout.write(' '.join(words))
@@ -96,13 +97,14 @@ def do_speak(self, args, extra, *, keyword_arg: Optional[str] = None) -> None:
         """Repeat what you tell me to."""
         words = []
         for word in extra:
+            modified_word = word
             if word is None:
-                word = ''
+                modified_word = ''
             if args.piglatin:
-                word = f'{word[1:]}{word[0]}ay'
+                modified_word = f'{word[1:]}{word[0]}ay'
             if args.shout:
-                word = word.upper()
-            words.append(word)
+                modified_word = word.upper()
+            words.append(modified_word)
         repetitions = args.repeat or 1
         for i in range(min(repetitions, self.maxrepeats)):
             self.stdout.write(' '.join(words))

tests/test_cmd2.py

@@ -61,15 +61,15 @@ def cmd_wrapper(*args, **kwargs):
     return arg_decorator
 
 
-def CreateOutsimApp():
+def create_outsim_app():
     c = cmd2.Cmd()
     c.stdout = utils.StdSim(c.stdout)
     return c
 
 
 @pytest.fixture
 def outsim_app():
-    return CreateOutsimApp()
+    return create_outsim_app()
 
 
 def test_version(base_app) -> None:
@@ -976,7 +976,7 @@ def test_base_cmdloop_with_startup_commands() -> None:
     expected = intro + '\n'
 
     with mock.patch.object(sys, 'argv', testargs):
-        app = CreateOutsimApp()
+        app = create_outsim_app()
 
     app.use_rawinput = True
 
@@ -991,7 +991,7 @@ def test_base_cmdloop_without_startup_commands() -> None:
     # Need to patch sys.argv so cmd2 doesn't think it was called with arguments equal to the py.test args
     testargs = ["prog"]
     with mock.patch.object(sys, 'argv', testargs):
-        app = CreateOutsimApp()
+        app = create_outsim_app()
 
     app.use_rawinput = True
     app.intro = 'Hello World, this is an intro ...'
@@ -1012,7 +1012,7 @@ def test_cmdloop_without_rawinput() -> None:
     # Need to patch sys.argv so cmd2 doesn't think it was called with arguments equal to the py.test args
     testargs = ["prog"]
     with mock.patch.object(sys, 'argv', testargs):
-        app = CreateOutsimApp()
+        app = create_outsim_app()
 
     app.use_rawinput = False
     app.echo = False

tests_isolated/test_commandset/test_commandset.py

@@ -832,7 +832,7 @@ def do_user_unrelated(self, ns: argparse.Namespace) -> None:
 
 
 def test_cross_commandset_completer(command_sets_manual, capsys) -> None:
-    global complete_states_expected_self
+    global complete_states_expected_self  # noqa: PLW0603
     # This tests the different ways to locate the matching CommandSet when completing an argparse argument.
     # Exercises the 3 cases in cmd2.Cmd._resolve_func_self() which is called during argparse tab completion.