cmd2 2.5.11__py3-none-any.whl → 2.6.0__py3-none-any.whl

cmd2/command_definition.py

@@ -1,15 +1,9 @@
-# coding=utf-8
-"""
-Supports the definition of commands in separate classes to be composed into cmd2.Cmd
-"""
+"""Supports the definition of commands in separate classes to be composed into cmd2.Cmd."""
 
+from collections.abc import Callable, Mapping
 from typing import (
     TYPE_CHECKING,
-    Callable,
-    Dict,
-    Mapping,
     Optional,
-    Type,
     TypeVar,
 )
 
@@ -31,13 +25,11 @@ if TYPE_CHECKING:  # pragma: no cover
 #: Further refinements are needed to define the input parameters
 CommandFunc = Callable[..., Optional[bool]]
 
-CommandSetType = TypeVar('CommandSetType', bound=Type['CommandSet'])
+CommandSetType = TypeVar('CommandSetType', bound=type['CommandSet'])
 
 
 def with_default_category(category: str, *, heritable: bool = True) -> Callable[[CommandSetType], CommandSetType]:
-    """
-    Decorator that applies a category to all ``do_*`` command methods in a class that do not already
-    have a category specified.
+    """Apply a category to all ``do_*`` command methods in a class that do not already have a category specified (Decorator).
 
     CommandSets that are decorated by this with `heritable` set to True (default) will set a class attribute that is
     inherited by all subclasses unless overridden. All commands of this CommandSet and all subclasses of this CommandSet
@@ -85,9 +77,8 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
     return decorate_class
 
 
-class CommandSet(object):
-    """
-    Base class for defining sets of commands to load in cmd2.
+class CommandSet:
+    """Base class for defining sets of commands to load in cmd2.
 
     ``with_default_category`` can be used to apply a default category to all commands in the CommandSet.
 
@@ -95,18 +86,19 @@ class CommandSet(object):
     """
 
     def __init__(self) -> None:
-        # Private reference to the CLI instance in which this CommandSet running.
-        # This will be set when the CommandSet is registered and it should be
-        # accessed by child classes using the self._cmd property.
+        """Private reference to the CLI instance in which this CommandSet running.
+
+        This will be set when the CommandSet is registered and it should be
+        accessed by child classes using the self._cmd property.
+        """
         self.__cmd_internal: Optional[cmd2.Cmd] = None
 
-        self._settables: Dict[str, Settable] = {}
+        self._settables: dict[str, Settable] = {}
         self._settable_prefix = self.__class__.__name__
 
     @property
     def _cmd(self) -> 'cmd2.Cmd':
-        """
-        Property for child classes to access self.__cmd_internal.
+        """Property for child classes to access self.__cmd_internal.
 
         Using this property ensures that self.__cmd_internal has been set
         and it tells type checkers that it's no longer a None type.
@@ -121,10 +113,11 @@ class CommandSet(object):
         return self.__cmd_internal
 
     def on_register(self, cmd: 'cmd2.Cmd') -> None:
-        """
-        Called by cmd2.Cmd as the first step to registering a CommandSet. The commands defined in this class have
-        not been added to the CLI object at this point. Subclasses can override this to perform any initialization
-        requiring access to the Cmd object (e.g. configure commands and their parsers based on CLI state data).
+        """First step to registering a CommandSet, called by cmd2.Cmd.
+
+        The commands defined in this class have not been added to the CLI object at this point.
+        Subclasses can override this to perform any initialization requiring access to the Cmd object
+        (e.g. configure commands and their parsers based on CLI state data).
 
         :param cmd: The cmd2 main application
         :raises CommandSetRegistrationError: if CommandSet is already registered.
@@ -135,66 +128,63 @@ class CommandSet(object):
             raise CommandSetRegistrationError('This CommandSet has already been registered')
 
     def on_registered(self) -> None:
-        """
-        Called by cmd2.Cmd after a CommandSet is registered and all its commands have been added to the CLI.
+        """2nd step to registering, called by cmd2.Cmd after a CommandSet is registered and all its commands have been added.
+
         Subclasses can override this to perform custom steps related to the newly added commands (e.g. setting
         them to a disabled state).
         """
-        pass
 
     def on_unregister(self) -> None:
+        """First step to unregistering a CommandSet, called by ``cmd2.Cmd``.
+
+        Subclasses can override this to perform any cleanup steps which require their commands being registered in the CLI.
         """
-        Called by ``cmd2.Cmd`` as the first step to unregistering a CommandSet. Subclasses can override this to
-        perform any cleanup steps which require their commands being registered in the CLI.
-        """
-        pass
 
     def on_unregistered(self) -> None:
-        """
-        Called by ``cmd2.Cmd`` after a CommandSet has been unregistered and all its commands removed from the CLI.
+        """2nd step to unregistering, called by ``cmd2.Cmd`` after a CommandSet is unregistered and all its commands removed.
+
         Subclasses can override this to perform remaining cleanup steps.
         """
         self.__cmd_internal = None
 
     @property
     def settable_prefix(self) -> str:
+        """Read-only accessor for the underlying private settable_prefix field."""
         return self._settable_prefix
 
     @property
     def settables(self) -> Mapping[str, Settable]:
+        """Read-only accessor for the underlying private settables field."""
         return self._settables
 
     def add_settable(self, settable: Settable) -> None:
-        """
-        Convenience method to add a settable parameter to the CommandSet
+        """Add a settable parameter to the CommandSet.
 
         :param settable: Settable object being added
         """
         if self.__cmd_internal is not None:
             if not self._cmd.always_prefix_settables:
-                if settable.name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
+                if settable.name in self._cmd.settables and settable.name not in self._settables:
                     raise KeyError(f'Duplicate settable: {settable.name}')
             else:
                 prefixed_name = f'{self._settable_prefix}.{settable.name}'
-                if prefixed_name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
+                if prefixed_name in self._cmd.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:
-        """
-        Convenience method for removing a settable parameter from the CommandSet
+        """Remove a settable parameter from the CommandSet.
 
         :param name: name of the settable being removed
         :raises KeyError: if the Settable matches this name
         """
         try:
             del self._settables[name]
-        except KeyError:
-            raise KeyError(name + " is not a settable parameter")
+        except KeyError as exc:
+            raise KeyError(name + " is not a settable parameter") from exc
 
     def sigint_handler(self) -> bool:
-        """
-        Handle a SIGINT that occurred for a command in this CommandSet.
+        """Handle a SIGINT that occurred for a command in this CommandSet.
 
         :return: True if this completes the interrupt handling and no KeyboardInterrupt will be raised.
                  False to raise a KeyboardInterrupt.

cmd2/constants.py

@@ -1,6 +1,4 @@
-#
-# coding=utf-8
-"""This module contains constants used throughout ``cmd2``."""
+"""Constants used throughout ``cmd2``."""
 
 # Unless documented in https://cmd2.readthedocs.io/en/latest/api/index.html
 # nothing here should be considered part of the public API of this module

cmd2/decorators.py

@@ -1,17 +1,11 @@
-# coding=utf-8
-"""Decorators for ``cmd2`` commands"""
+"""Decorators for ``cmd2`` commands."""
 
 import argparse
+from collections.abc import Callable, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    List,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
@@ -38,13 +32,12 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
-    """A decorator to apply a category to a ``do_*`` command method.
+    """Decorate a ``do_*`` command method to apply a category.
 
     :param category: the name of the category in which this command should
                      be grouped when displaying the list of commands.
 
     Example:
-
     ```py
     class MyApp(cmd2.Cmd):
         @cmd2.with_category('Text Functions')
@@ -54,6 +47,7 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
 
     For an alternative approach to categorizing commands using a function, see
     [cmd2.utils.categorize][]
+
     """
 
     def cat_decorator(func: CommandFunc) -> CommandFunc:
@@ -68,7 +62,7 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
 
 
 CommandParent = TypeVar('CommandParent', bound=Union['cmd2.Cmd', CommandSet])
-CommandParentType = TypeVar('CommandParentType', bound=Union[Type['cmd2.Cmd'], Type[CommandSet]])
+CommandParentType = TypeVar('CommandParentType', bound=Union[type['cmd2.Cmd'], type[CommandSet]])
 
 
 RawCommandFuncOptionalBoolReturn = Callable[[CommandParent, Union[Statement, str]], Optional[bool]]
@@ -79,12 +73,13 @@ RawCommandFuncOptionalBoolReturn = Callable[[CommandParent, Union[Statement, str
 # in cmd2 command functions/callables. As long as the 2-ple of arguments we expect to be there can be
 # found we can swap out the statement with each decorator's specific parameters
 ##########################
-def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Statement, str]]:
-    """
-    Helper function for cmd2 decorators to inspect the positional arguments until the cmd2.Cmd argument is found
+def _parse_positionals(args: tuple[Any, ...]) -> tuple['cmd2.Cmd', Union[Statement, str]]:
+    """Inspect the positional arguments until the cmd2.Cmd argument is found.
+
     Assumes that we will find cmd2.Cmd followed by the command statement object or string.
+
     :arg args: The positional arguments to inspect
-    :return: The cmd2.Cmd reference and the command line statement
+    :return: The cmd2.Cmd reference and the command line statement.
     """
     for pos, arg in enumerate(args):
         from cmd2 import (
@@ -93,7 +88,7 @@ def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Stateme
 
         if isinstance(arg, (Cmd, CommandSet)) and len(args) > pos + 1:
             if isinstance(arg, CommandSet):
-                arg = arg._cmd
+                arg = arg._cmd  # noqa: PLW2901
             next_arg = args[pos + 1]
             if isinstance(next_arg, (Statement, str)):
                 return arg, args[pos + 1]
@@ -103,9 +98,8 @@ def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Stateme
     raise TypeError('Expected arguments: cmd: cmd2.Cmd, statement: Union[Statement, str] Not found')
 
 
-def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) -> List[Any]:
-    """
-    Helper function for cmd2 decorators to swap the Statement parameter with one or more decorator-specific parameters
+def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) -> list[Any]:
+    """Swap the Statement parameter with one or more decorator-specific parameters.
 
     :param args: The original positional arguments
     :param search_arg: The argument to search for (usually the Statement)
@@ -120,13 +114,13 @@ def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) ->
 
 #: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and optionally returns a boolean
-ArgListCommandFuncOptionalBoolReturn = Callable[[CommandParent, List[str]], Optional[bool]]
+ArgListCommandFuncOptionalBoolReturn = Callable[[CommandParent, list[str]], Optional[bool]]
 #: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and returns a boolean
-ArgListCommandFuncBoolReturn = Callable[[CommandParent, List[str]], bool]
+ArgListCommandFuncBoolReturn = Callable[[CommandParent, list[str]], bool]
 #: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and returns Nothing
-ArgListCommandFuncNoneReturn = Callable[[CommandParent, List[str]], None]
+ArgListCommandFuncNoneReturn = Callable[[CommandParent, list[str]], None]
 
 #: Aggregate of all accepted function signatures for command functions that accept a pre-processed argument list
 ArgListCommandFunc = Union[
@@ -144,9 +138,9 @@ def with_argument_list(
     RawCommandFuncOptionalBoolReturn[CommandParent],
     Callable[[ArgListCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]],
 ]:
-    """
-    A decorator to alter the arguments passed to a ``do_*`` method. Default
-    passes a string of whatever the user typed. With this decorator, the
+    """Decorate a ``do_*`` method to alter the arguments passed to it so it is passed a list[str].
+
+    Default passes a string of whatever the user typed. With this decorator, the
     decorated method will receive a list of arguments parsed from user input.
 
     :param func_arg: Single-element positional argument list containing ``doi_*`` method
@@ -161,12 +155,13 @@ def with_argument_list(
         def do_echo(self, arglist):
             self.poutput(' '.join(arglist)
     ```
+
     """
     import functools
 
     def arg_decorator(func: ArgListCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
-        """
-        Decorator function that ingests an Argument List function and returns a raw command function.
+        """Decorate function that ingests an Argument List function and returns a raw command function.
+
         The returned function will process the raw input into an argument list to be passed to the wrapped function.
 
         :param func: The defined argument list command function
@@ -175,8 +170,7 @@ def with_argument_list(
 
         @functools.wraps(func)
         def cmd_wrapper(*args: Any, **kwargs: Any) -> Optional[bool]:
-            """
-            Command function wrapper which translates command line into an argument list and calls actual command function
+            """Command function wrapper which translates command line into an argument list and calls actual command function.
 
             :param args: All positional arguments to this function.  We're expecting there to be:
                             cmd2_app, statement: Union[Statement, str]
@@ -195,21 +189,20 @@ def with_argument_list(
 
     if callable(func_arg):
         return arg_decorator(func_arg)
-    else:
-        return arg_decorator
+    return arg_decorator
 
 
 def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
-    """
-    Recursively set prog attribute of a parser and all of its subparsers so that the root command
-    is a command name and not sys.argv[0].
+    """Recursively set prog attribute of a parser and all of its subparsers.
+
+    Does so that the root command is a command name and not sys.argv[0].
 
     :param parser: the parser being edited
     :param prog: new value for the parser's prog attribute
     """
     # Set the prog value for this parser
     parser.prog = prog
-    req_args: List[str] = []
+    req_args: list[str] = []
 
     # Set the prog value for the parser's subcommands
     for action in parser._actions:
@@ -245,24 +238,24 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
             break
 
         # Need to save required args so they can be prepended to the subcommand usage
-        elif action.required:
+        if action.required:
             req_args.append(action.dest)
 
 
 #: Function signatures for command functions that use an argparse.ArgumentParser to process user input
 #: and optionally return a boolean
 ArgparseCommandFuncOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace], Optional[bool]]
-ArgparseCommandFuncWithUnknownArgsOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace, List[str]], Optional[bool]]
+ArgparseCommandFuncWithUnknownArgsOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace, list[str]], Optional[bool]]
 
 #: Function signatures for command functions that use an argparse.ArgumentParser to process user input
 #: and return a boolean
 ArgparseCommandFuncBoolReturn = Callable[[CommandParent, argparse.Namespace], bool]
-ArgparseCommandFuncWithUnknownArgsBoolReturn = Callable[[CommandParent, argparse.Namespace, List[str]], bool]
+ArgparseCommandFuncWithUnknownArgsBoolReturn = Callable[[CommandParent, argparse.Namespace, list[str]], bool]
 
 #: Function signatures for command functions that use an argparse.ArgumentParser to process user input
 #: and return nothing
 ArgparseCommandFuncNoneReturn = Callable[[CommandParent, argparse.Namespace], None]
-ArgparseCommandFuncWithUnknownArgsNoneReturn = Callable[[CommandParent, argparse.Namespace, List[str]], None]
+ArgparseCommandFuncWithUnknownArgsNoneReturn = Callable[[CommandParent, argparse.Namespace, list[str]], None]
 
 #: Aggregate of all accepted function signatures for an argparse command function
 ArgparseCommandFunc = Union[
@@ -286,8 +279,7 @@ def with_argparser(
     preserve_quotes: bool = False,
     with_unknown_args: bool = False,
 ) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]:
-    """A decorator to alter a cmd2 method to populate its ``args`` argument by parsing arguments
-    with the given instance of argparse.ArgumentParser.
+    """Decorate a ``do_*`` method to populate its ``args`` argument with the given instance of argparse.ArgumentParser.
 
     :param parser: unique instance of ArgumentParser or a callable that returns an ArgumentParser
     :param ns_provider: An optional function that accepts a cmd2.Cmd or cmd2.CommandSet object as an argument and returns an
@@ -301,7 +293,6 @@ def with_argparser(
              parsing the command line. This can be useful if the command function needs to know the command line.
 
     Example:
-
     ```py
     parser = cmd2.Cmd2ArgumentParser()
     parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
@@ -331,12 +322,13 @@ def with_argparser(
             self.poutput(f'args: {args!r}')
             self.poutput(f'unknowns: {unknown}')
     ```
+
     """
     import functools
 
     def arg_decorator(func: ArgparseCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
-        """
-        Decorator function that ingests an Argparse Command Function and returns a raw command function.
+        """Decorate function that ingests an Argparse Command Function and returns a raw command function.
+
         The returned function will process the raw input into an argparse Namespace to be passed to the wrapped function.
 
         :param func: The defined argparse command function
@@ -344,10 +336,8 @@ def with_argparser(
         """
 
         @functools.wraps(func)
-        def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
-            """
-            Command function wrapper which translates command line into argparse Namespace and calls actual
-            command function
+        def cmd_wrapper(*args: Any, **kwargs: dict[str, Any]) -> Optional[bool]:
+            """Command function wrapper which translates command line into argparse Namespace and call actual command function.
 
             :param args: All positional arguments to this function.  We're expecting there to be:
                             cmd2_app, statement: Union[Statement, str]
@@ -377,21 +367,21 @@ def with_argparser(
                 namespace = ns_provider(provider_self if provider_self is not None else cmd2_app)
 
             try:
-                new_args: Union[Tuple[argparse.Namespace], Tuple[argparse.Namespace, List[str]]]
+                new_args: Union[tuple[argparse.Namespace], tuple[argparse.Namespace, list[str]]]
                 if with_unknown_args:
                     new_args = arg_parser.parse_known_args(parsed_arglist, namespace)
                 else:
                     new_args = (arg_parser.parse_args(parsed_arglist, namespace),)
                 ns = new_args[0]
-            except SystemExit:
-                raise Cmd2ArgparseError
+            except SystemExit as exc:
+                raise Cmd2ArgparseError from exc
             else:
                 # Add wrapped statement to Namespace as cmd2_statement
-                setattr(ns, 'cmd2_statement', Cmd2AttributeWrapper(statement))
+                ns.cmd2_statement = Cmd2AttributeWrapper(statement)
 
                 # Add wrapped subcmd handler (which can be None) to Namespace as cmd2_handler
                 handler = getattr(ns, constants.NS_ATTR_SUBCMD_HANDLER, None)
-                setattr(ns, 'cmd2_handler', Cmd2AttributeWrapper(handler))
+                ns.cmd2_handler = Cmd2AttributeWrapper(handler)
 
                 # Remove the subcmd handler attribute from the Namespace
                 # since cmd2_handler is how a developer accesses it.
@@ -421,11 +411,10 @@ def as_subcommand_to(
         Callable[[CommandParentType], argparse.ArgumentParser],  # Cmd or CommandSet classmethod
     ],
     *,
-    help: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
+    help: Optional[str] = None,  # noqa: A002
+    aliases: Optional[list[str]] = None,
 ) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]:
-    """
-    Tag this method as a subcommand to an existing argparse decorated command.
+    """Tag this method as a subcommand to an existing argparse decorated command.
 
     :param command: Command Name. Space-delimited subcommands may optionally be specified
     :param subcommand: Subcommand name
@@ -444,7 +433,7 @@ def as_subcommand_to(
         setattr(func, constants.SUBCMD_ATTR_NAME, subcommand)
 
         # Keyword arguments for subparsers.add_parser()
-        add_parser_kwargs: Dict[str, Any] = dict()
+        add_parser_kwargs: dict[str, Any] = {}
         if help is not None:
             add_parser_kwargs['help'] = help
         if aliases:

cmd2/exceptions.py

@@ -1,51 +1,36 @@
-# coding=utf-8
-"""Custom exceptions for cmd2"""
+"""Custom exceptions for cmd2."""
 
-from typing import (
-    Any,
-)
+from typing import Any
 
 ############################################################################################################
 # The following exceptions are part of the public API
 ############################################################################################################
 
 
-class SkipPostcommandHooks(Exception):
-    """
-    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.
-    """
-
-    pass
+class SkipPostcommandHooks(Exception):  # noqa: N818
+    """For when a command has a failed bad enough to skip post command hooks, but not bad enough to print to the user."""
 
 
 class Cmd2ArgparseError(SkipPostcommandHooks):
-    """
-    A ``SkipPostcommandHooks`` exception for when a command fails to parse its arguments.
+    """A ``SkipPostcommandHooks`` exception for when a command fails to parse its arguments.
+
     Normally argparse raises a SystemExit exception in these cases. To avoid stopping the command
     loop, catch the SystemExit and raise this instead. If you still need to run post command hooks
     after parsing fails, just return instead of raising an exception.
     """
 
-    pass
-
 
 class CommandSetRegistrationError(Exception):
-    """
-    Exception that can be thrown when an error occurs while a CommandSet is being added or removed
-    from a cmd2 application.
-    """
-
-    pass
+    """For when an error occurs while a CommandSet is being added or removed from a cmd2 application."""
 
 
 class CompletionError(Exception):
-    """
-    Raised during tab completion operations to report any sort of error you want printed. This can also be used
-    just to display a message, even if it's not an error. For instance, ArgparseCompleter raises CompletionErrors
-    to display tab completion hints and sets apply_style to False so hints aren't colored like error text.
+    """Raised during tab completion operations to report any sort of error you want printed.
+
+    This can also be used just to display a message, even if it's not an error. For instance, ArgparseCompleter raises
+    CompletionErrors to display tab completion hints and sets apply_style to False so hints aren't colored like error text.
 
-    Example use cases
+    Example use cases:
 
     - Reading a database to retrieve a tab completion data set failed
     - A previous command line argument that determines the data set being completed is invalid
@@ -53,8 +38,8 @@ class CompletionError(Exception):
     """
 
     def __init__(self, *args: Any, apply_style: bool = True) -> None:
-        """
-        Initializer for CompletionError
+        """Initialize CompletionError instance.
+
         :param apply_style: If True, then ansi.style_error will be applied to the message text when printed.
                             Set to False in cases where the message text already has the desired style.
                             Defaults to True.
@@ -64,16 +49,16 @@ class CompletionError(Exception):
         super().__init__(*args)
 
 
-class PassThroughException(Exception):
-    """
-    Normally all unhandled exceptions raised during commands get printed to the user.
+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.
     """
 
     def __init__(self, *args: Any, wrapped_ex: BaseException) -> None:
-        """
-        Initializer for PassThroughException
-        :param wrapped_ex: the exception that will be raised
+        """Initialize PassThroughException instance.
+
+        :param wrapped_ex: the exception that will be raised.
         """
         self.wrapped_ex = wrapped_ex
         super().__init__(*args)
@@ -85,24 +70,16 @@ class PassThroughException(Exception):
 
 
 class Cmd2ShlexError(Exception):
-    """Raised when shlex fails to parse a command line string in StatementParser"""
-
-    pass
+    """Raised when shlex fails to parse a command line string in StatementParser."""
 
 
 class EmbeddedConsoleExit(SystemExit):
     """Custom exception class for use with the py command."""
 
-    pass
-
 
-class EmptyStatement(Exception):
+class EmptyStatement(Exception):  # noqa: N818
     """Custom exception class for handling behavior when the user just presses <Enter>."""
 
-    pass
-
 
 class RedirectionError(Exception):
-    """Custom exception class for when redirecting or piping output fails"""
-
-    pass
+    """Custom exception class for when redirecting or piping output fails."""