Merge branch 'master' into 3.0.0

Author: tleonhardt

cmd2/__init__.py

@@ -1,14 +1,12 @@
 """This simply imports certain things for backwards compatibility."""
 
 import argparse
+import contextlib
 import importlib.metadata as importlib_metadata
 import sys
 
-try:
+with contextlib.suppress(importlib_metadata.PackageNotFoundError):
     __version__ = importlib_metadata.version(__name__)
-except importlib_metadata.PackageNotFoundError:  # pragma: no cover
-    # package is not installed
-    pass
 
 from .ansi import (
     Bg,
@@ -54,7 +52,7 @@
 from .py_bridge import CommandResult
 from .utils import CompletionMode, CustomCompletionSettings, Settable, categorize
 
-__all__: list[str] = [
+__all__: list[str] = [  # noqa: RUF022
     'COMMAND_NAME',
     'DEFAULT_SHORTCUTS',
     # ANSI Exports

cmd2/argparse_completer.py

@@ -92,11 +92,7 @@ def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
         return False
 
     # Flags can't have a space
-    if ' ' in token:
-        return False
-
-    # Starts like a flag
-    return True
+    return ' ' not in token
 
 
 class _ArgumentState:
@@ -368,34 +364,30 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
             # Otherwise treat as a positional argument
             else:
                 # If we aren't current tracking a positional, then get the next positional arg to handle this token
-                if pos_arg_state is None:
-                    # Make sure we are still have positional arguments to parse
-                    if remaining_positionals:
-                        action = remaining_positionals.popleft()
-
-                        # Are we at a subcommand? If so, forward to the matching completer
-                        if action == self._subcommand_action:
-                            if token in self._subcommand_action.choices:
-                                # Merge self._parent_tokens and consumed_arg_values
-                                parent_tokens = {**self._parent_tokens, **consumed_arg_values}
-
-                                # Include the subcommand name if its destination was set
-                                if action.dest != argparse.SUPPRESS:
-                                    parent_tokens[action.dest] = [token]
-
-                                parser: argparse.ArgumentParser = self._subcommand_action.choices[token]
-                                completer_type = self._cmd2_app._determine_ap_completer_type(parser)
-
-                                completer = completer_type(parser, self._cmd2_app, parent_tokens=parent_tokens)
-
-                                return completer.complete(
-                                    text, line, begidx, endidx, tokens[token_index + 1 :], cmd_set=cmd_set
-                                )
-                            # Invalid subcommand entered, so no way to complete remaining tokens
-                            return []
-
-                        # Otherwise keep track of the argument
-                        pos_arg_state = _ArgumentState(action)
+                if pos_arg_state is None and remaining_positionals:
+                    action = remaining_positionals.popleft()
+
+                    # Are we at a subcommand? If so, forward to the matching completer
+                    if action == self._subcommand_action:
+                        if token in self._subcommand_action.choices:
+                            # Merge self._parent_tokens and consumed_arg_values
+                            parent_tokens = {**self._parent_tokens, **consumed_arg_values}
+
+                            # Include the subcommand name if its destination was set
+                            if action.dest != argparse.SUPPRESS:
+                                parent_tokens[action.dest] = [token]
+
+                            parser: argparse.ArgumentParser = self._subcommand_action.choices[token]
+                            completer_type = self._cmd2_app._determine_ap_completer_type(parser)
+
+                            completer = completer_type(parser, self._cmd2_app, parent_tokens=parent_tokens)
+
+                            return completer.complete(text, line, begidx, endidx, tokens[token_index + 1 :], cmd_set=cmd_set)
+                        # Invalid subcommand entered, so no way to complete remaining tokens
+                        return []
+
+                    # Otherwise keep track of the argument
+                    pos_arg_state = _ArgumentState(action)
 
                 # Check if we have a positional to consume this token
                 if pos_arg_state is not None:

cmd2/argparse_custom.py

@@ -840,12 +840,8 @@ def _add_argument_wrapper(
 def _get_nargs_pattern_wrapper(self: argparse.ArgumentParser, action: argparse.Action) -> str:
     # Wrapper around ArgumentParser._get_nargs_pattern behavior to support nargs ranges
     nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]
-    if nargs_range is not None:
-        if nargs_range[1] == constants.INFINITY:
-            range_max = ''
-        else:
-            range_max = nargs_range[1]
-
+    if nargs_range:
+        range_max = '' if nargs_range[1] == constants.INFINITY else nargs_range[1]
         nargs_pattern = f'(-*A{{{nargs_range[0]},{range_max}}}-*)'
 
         # if this is an optional action, -- is not allowed
@@ -1364,14 +1360,12 @@ def add_subparsers(self, **kwargs: Any) -> argparse._SubParsersAction:  # type:
     def error(self, message: str) -> NoReturn:
         """Custom override that applies custom formatting to the error message."""
         lines = message.split('\n')
-        linum = 0
         formatted_message = ''
-        for line in lines:
+        for linum, line in enumerate(lines):
             if linum == 0:
                 formatted_message = 'Error: ' + line
             else:
                 formatted_message += '\n       ' + line
-            linum += 1
 
         self.print_usage(sys.stderr)
         formatted_message = ansi.style_error(formatted_message)

cmd2/cmd2.py

@@ -30,6 +30,7 @@
 # setting is True
 import argparse
 import cmd
+import contextlib
 import copy
 import functools
 import glob
@@ -47,10 +48,6 @@
     namedtuple,
 )
 from collections.abc import Callable, Iterable, Mapping
-from contextlib import (
-    redirect_stdout,
-    suppress,
-)
 from types import (
     FrameType,
     ModuleType,
@@ -121,10 +118,8 @@
 )
 
 # NOTE: When using gnureadline with Python 3.13, start_ipython needs to be imported before any readline-related stuff
-try:
+with contextlib.suppress(ImportError):
     from IPython import start_ipython  # type: ignore[import]
-except ImportError:
-    pass
 
 from .rl_utils import (
     RlType,
@@ -284,7 +279,7 @@ def remove(self, command_method: CommandFunc) -> None:
 class Cmd(cmd.Cmd):
     """An easy but powerful framework for writing line-oriented command interpreters.
 
-    Extends the Python Standard Library’s cmd package by adding a lot of useful features
+    Extends the Python Standard Library's cmd package by adding a lot of useful features
     to the out of the box configuration.
 
     Line-oriented command interpreters are often useful for test harnesses, internal tools, and rapid prototypes.
@@ -1088,9 +1083,8 @@ def add_settable(self, settable: Settable) -> None:
 
         :param settable: Settable object being added
         """
-        if not self.always_prefix_settables:
-            if settable.name in self.settables and settable.name not in self._settables:
-                raise KeyError(f'Duplicate settable: {settable.name}')
+        if not self.always_prefix_settables and settable.name in self.settables and settable.name not in self._settables:
+            raise KeyError(f'Duplicate settable: {settable.name}')
         self._settables[settable.name] = settable
 
     def remove_settable(self, name: str) -> None:
@@ -1296,7 +1290,7 @@ def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False) -> None:
         # Don't try to use the pager when being run by a continuous integration system like Jenkins + pexpect.
         functional_terminal = False
 
-        if self.stdin.isatty() and self.stdout.isatty():
+        if self.stdin.isatty() and self.stdout.isatty():  # noqa: SIM102
             if sys.platform.startswith('win') or os.environ.get('TERM') is not None:
                 functional_terminal = True
 
@@ -2725,8 +2719,8 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
             read_fd, write_fd = os.pipe()
 
             # Open each side of the pipe
-            subproc_stdin = open(read_fd)
-            new_stdout: TextIO = cast(TextIO, open(write_fd, 'w'))
+            subproc_stdin = open(read_fd)  # noqa: SIM115
+            new_stdout: TextIO = cast(TextIO, open(write_fd, 'w'))  # noqa: SIM115
 
             # Create pipe process in a separate group to isolate our signals from it. If a Ctrl-C event occurs,
             # our sigint handler will forward it only to the most recent pipe process. This makes sure pipe
@@ -2756,7 +2750,7 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
             # like: !ls -l | grep user | wc -l > out.txt. But this makes it difficult to know if the pipe process
             # started OK, since the shell itself always starts. Therefore, we will wait a short time and check
             # if the pipe process is still running.
-            with suppress(subprocess.TimeoutExpired):
+            with contextlib.suppress(subprocess.TimeoutExpired):
                 proc.wait(0.2)
 
             # Check if the pipe process already exited
@@ -2776,7 +2770,7 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
                 mode = 'a' if statement.output == constants.REDIRECTION_APPEND else 'w'
                 try:
                     # Use line buffering
-                    new_stdout = cast(TextIO, open(utils.strip_quotes(statement.output_to), mode=mode, buffering=1))
+                    new_stdout = cast(TextIO, open(utils.strip_quotes(statement.output_to), mode=mode, buffering=1))  # noqa: SIM115
                 except OSError as ex:
                     raise RedirectionError(f'Failed to redirect because: {ex}')
 
@@ -2797,7 +2791,7 @@ def _redirect_output(self, statement: Statement) -> utils.RedirectionSavedState:
                 # no point opening up the temporary file
                 current_paste_buffer = get_paste_buffer()
                 # create a temporary file to store output
-                new_stdout = cast(TextIO, tempfile.TemporaryFile(mode="w+"))
+                new_stdout = cast(TextIO, tempfile.TemporaryFile(mode="w+"))  # noqa: SIM115
                 redir_saved_state.redirecting = True
                 sys.stdout = self.stdout = new_stdout
 
@@ -2823,11 +2817,9 @@ def _restore_output(self, statement: Statement, saved_redir_state: utils.Redirec
                 self.stdout.seek(0)
                 write_to_paste_buffer(self.stdout.read())
 
-            try:
+            with contextlib.suppress(BrokenPipeError):
                 # Close the file or pipe that stdout was redirected to
                 self.stdout.close()
-            except BrokenPipeError:
-                pass
 
             # Restore the stdout values
             self.stdout = cast(TextIO, saved_redir_state.saved_self_stdout)
@@ -3081,11 +3073,9 @@ def _read_command_line(self, prompt: str) -> str:
         """
         try:
             # Wrap in try since terminal_lock may not be locked
-            try:
+            with contextlib.suppress(RuntimeError):
                 # Command line is about to be drawn. Allow asynchronous changes to the terminal.
                 self.terminal_lock.release()
-            except RuntimeError:
-                pass
             return self.read_input(prompt, completion_mode=utils.CompletionMode.COMMANDS)
         except EOFError:
             return 'eof'
@@ -3622,7 +3612,7 @@ def _print_topics(self, header: str, cmds: list[str], verbose: bool) -> None:
                         result = io.StringIO()
 
                         # try to redirect system stdout
-                        with redirect_stdout(result):
+                        with contextlib.redirect_stdout(result):
                             # save our internal stdout
                             stdout_orig = self.stdout
                             try:
@@ -3948,7 +3938,7 @@ def _reset_py_display() -> None:
         # Delete any prompts that have been set
         attributes = ['ps1', 'ps2', 'ps3']
         for cur_attr in attributes:
-            with suppress(KeyError):
+            with contextlib.suppress(KeyError):
                 del sys.__dict__[cur_attr]
 
         # Reset functions
@@ -4126,7 +4116,7 @@ def py_quit() -> None:
 
             # Check if we are running Python code
             if py_code_to_run:
-                try:
+                try:  # noqa: SIM105
                     interp.runcode(py_code_to_run)  # type: ignore[arg-type]
                 except BaseException:  # noqa: BLE001, S110
                     # We don't care about any exception that happened in the Python code
@@ -4377,7 +4367,7 @@ def do_history(self, args: argparse.Namespace) -> Optional[bool]:
         self.last_result = False
 
         # -v must be used alone with no other options
-        if args.verbose:
+        if args.verbose:  # noqa: SIM102
             if args.clear or args.edit or args.output_file or args.run or args.transcript or args.expanded or args.script:
                 self.poutput("-v cannot be used with any other options")
                 return None

cmd2/rl_utils.py

@@ -1,5 +1,6 @@
 """Imports the proper Readline for the platform and provides utility functions for it."""
 
+import contextlib
 import sys
 from enum import (
     Enum,
@@ -27,10 +28,8 @@
     import gnureadline as readline  # type: ignore[import]
 except ImportError:
     # Note: If this actually fails, you should install gnureadline on Linux/Mac or pyreadline3 on Windows.
-    try:
+    with contextlib.suppress(ImportError):
         import readline  # type: ignore[no-redef]
-    except ImportError:  # pragma: no cover
-        pass
 
 
 class RlType(Enum):

cmd2/transcript.py

@@ -64,9 +64,8 @@ def _fetch_transcripts(self) -> None:
         self.transcripts = {}
         testfiles = cast(list[str], getattr(self.cmdapp, 'testfiles', []))
         for fname in testfiles:
-            tfile = open(fname)
-            self.transcripts[fname] = iter(tfile.readlines())
-            tfile.close()
+            with open(fname) as tfile:
+                self.transcripts[fname] = iter(tfile.readlines())
 
     def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
         if self.cmdapp is None:

cmd2/utils.py

@@ -2,6 +2,7 @@
 
 import argparse
 import collections
+import contextlib
 import functools
 import glob
 import inspect
@@ -530,7 +531,7 @@ class ByteBuf:
     """Used by StdSim to write binary data and stores the actual bytes written."""
 
     # Used to know when to flush the StdSim
-    NEWLINES = [b'\n', b'\r']
+    NEWLINES = (b'\n', b'\r')
 
     def __init__(self, std_sim_instance: StdSim) -> None:
         self.byte_buf = bytearray()
@@ -646,11 +647,9 @@ def _write_bytes(stream: Union[StdSim, TextIO], to_write: Union[bytes, str]) ->
         if isinstance(to_write, str):
             to_write = to_write.encode()
 
-        try:
+        # BrokenPipeError can occur if output is being piped to a process that closed
+        with contextlib.suppress(BrokenPipeError):
             stream.buffer.write(to_write)
-        except BrokenPipeError:
-            # This occurs if output is being piped to a process that closed
-            pass
 
 
 class ContextFlag:
@@ -877,12 +876,8 @@ def align_text(
         line_styles = list(get_styles_dict(line).values())
 
         # Calculate how wide each side of filling needs to be
-        if line_width >= width:
-            # Don't return here even though the line needs no fill chars.
-            # There may be styles sequences to restore.
-            total_fill_width = 0
-        else:
-            total_fill_width = width - line_width
+        total_fill_width = 0 if line_width >= width else width - line_width
+        # Even if the line needs no fill chars, there may be styles sequences to restore
 
         if alignment == TextAlignment.LEFT:
             left_fill_width = 0

examples/cmd_as_argument.py

@@ -21,9 +21,9 @@ class CmdLineApp(cmd2.Cmd):
 
     # Setting this true makes it run a shell command if a cmd2/cmd command doesn't exist
     # default_to_shell = True  # noqa: ERA001
-    MUMBLES = ['like', '...', 'um', 'er', 'hmmm', 'ahh']
-    MUMBLE_FIRST = ['so', 'like', 'well']
-    MUMBLE_LAST = ['right?']
+    MUMBLES = ('like', '...', 'um', 'er', 'hmmm', 'ahh')
+    MUMBLE_FIRST = ('so', 'like', 'well')
+    MUMBLE_LAST = ('right?',)
 
     def __init__(self) -> None:
         shortcuts = dict(cmd2.DEFAULT_SHORTCUTS)

examples/custom_parser.py

@@ -25,14 +25,12 @@ def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
     def error(self, message: str) -> NoReturn:
         """Custom override that applies custom formatting to the error message."""
         lines = message.split('\n')
-        linum = 0
         formatted_message = ''
-        for line in lines:
+        for linum, line in enumerate(lines):
             if linum == 0:
                 formatted_message = 'Error: ' + line
             else:
                 formatted_message += '\n       ' + line
-            linum += 1
 
         self.print_usage(sys.stderr)