cmd2 2.4.3__py3-none-any.whl → 2.5.1__py3-none-any.whl

cmd2/__init__.py

@@ -5,12 +5,8 @@
 
 import sys
 
-# For python 3.8 and later
-if sys.version_info >= (3, 8):
-    import importlib.metadata as importlib_metadata
-else:
-    # For everyone else
-    import importlib_metadata
+import importlib.metadata as importlib_metadata
+
 try:
     __version__ = importlib_metadata.version(__name__)
 except importlib_metadata.PackageNotFoundError:  # pragma: no cover

cmd2/ansi.py

@@ -2,7 +2,8 @@
 """
 Support for ANSI escape sequences which are used for things like applying style to text,
 setting the window title, and asynchronous alerts.
- """
+"""
+
 import functools
 import re
 from enum import (
@@ -62,25 +63,25 @@ The default is ``AllowStyle.TERMINAL``.
 """
 
 # Regular expression to match ANSI style sequence
-ANSI_STYLE_RE = re.compile(fr'{ESC}\[[^m]*m')
+ANSI_STYLE_RE = re.compile(rf'{ESC}\[[^m]*m')
 
 # Matches standard foreground colors: CSI(30-37|90-97|39)m
-STD_FG_RE = re.compile(fr'{ESC}\[(?:[39][0-7]|39)m')
+STD_FG_RE = re.compile(rf'{ESC}\[(?:[39][0-7]|39)m')
 
 # Matches standard background colors: CSI(40-47|100-107|49)m
-STD_BG_RE = re.compile(fr'{ESC}\[(?:(?:4|10)[0-7]|49)m')
+STD_BG_RE = re.compile(rf'{ESC}\[(?:(?:4|10)[0-7]|49)m')
 
 # Matches eight-bit foreground colors: CSI38;5;(0-255)m
-EIGHT_BIT_FG_RE = re.compile(fr'{ESC}\[38;5;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])m')
+EIGHT_BIT_FG_RE = re.compile(rf'{ESC}\[38;5;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])m')
 
 # Matches eight-bit background colors: CSI48;5;(0-255)m
-EIGHT_BIT_BG_RE = re.compile(fr'{ESC}\[48;5;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])m')
+EIGHT_BIT_BG_RE = re.compile(rf'{ESC}\[48;5;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])m')
 
 # Matches RGB foreground colors: CSI38;2;(0-255);(0-255);(0-255)m
-RGB_FG_RE = re.compile(fr'{ESC}\[38;2(?:;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])){{3}}m')
+RGB_FG_RE = re.compile(rf'{ESC}\[38;2(?:;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])){{3}}m')
 
 # Matches RGB background colors: CSI48;2;(0-255);(0-255);(0-255)m
-RGB_BG_RE = re.compile(fr'{ESC}\[48;2(?:;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])){{3}}m')
+RGB_BG_RE = re.compile(rf'{ESC}\[48;2(?:;(?:1?[0-9]?[0-9]?|2[0-4][0-9]|25[0-5])){{3}}m')
 
 
 def strip_style(text: str) -> str:
@@ -224,7 +225,6 @@ class BgColor(AnsiSequence):
 ####################################################################################
 # Implementations intended for direct use
 ####################################################################################
-# noinspection PyPep8Naming
 class Cursor:
     """Create ANSI sequences to alter the cursor position"""
 
@@ -1042,6 +1042,9 @@ def style(
 # Default styles for printing strings of various types.
 # These can be altered to suit an application's needs and only need to be a
 # function with the following structure: func(str) -> str
+style_output = functools.partial(style)
+"""Partial function supplying arguments to :meth:`cmd2.ansi.style()` which colors text for normal output"""
+
 style_success = functools.partial(style, fg=Fg.GREEN)
 """Partial function supplying arguments to :meth:`cmd2.ansi.style()` which colors text to signify success"""
 
@@ -1056,7 +1059,7 @@ def async_alert_str(*, terminal_columns: int, prompt: str, line: str, cursor_off
     """Calculate the desired string, including ANSI escape codes, for displaying an asynchronous alert message.
 
     :param terminal_columns: terminal width (number of columns)
-    :param prompt: prompt that is displayed on the current line
+    :param prompt: current onscreen prompt
     :param line: current contents of the Readline line buffer
     :param cursor_offset: the offset of the current cursor position within line
     :param alert_msg: the message to display to the user
@@ -1069,9 +1072,9 @@ def async_alert_str(*, terminal_columns: int, prompt: str, line: str, cursor_off
     # Calculate how many terminal lines are taken up by all prompt lines except for the last one.
     # That will be included in the input lines calculations since that is where the cursor is.
     num_prompt_terminal_lines = 0
-    for line in prompt_lines[:-1]:
-        line_width = style_aware_wcswidth(line)
-        num_prompt_terminal_lines += int(line_width / terminal_columns) + 1
+    for prompt_line in prompt_lines[:-1]:
+        prompt_line_width = style_aware_wcswidth(prompt_line)
+        num_prompt_terminal_lines += int(prompt_line_width / terminal_columns) + 1
 
     # Now calculate how many terminal lines are take up by the input
     last_prompt_line = prompt_lines[-1]

cmd2/argparse_completer.py

@@ -61,7 +61,6 @@ DEFAULT_DESCRIPTIVE_HEADER = 'Description'
 ARG_TOKENS = 'arg_tokens'
 
 
-# noinspection PyProtectedMember
 def _build_hint(parser: argparse.ArgumentParser, arg_action: argparse.Action) -> str:
     """Build tab completion hint for a given argument"""
     # Check if hinting is disabled for this argument
@@ -82,7 +81,6 @@ def _single_prefix_char(token: str, parser: argparse.ArgumentParser) -> bool:
     return len(token) == 1 and token[0] in parser.prefix_chars
 
 
-# noinspection PyProtectedMember
 def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
     """
     Determine if a token looks like a flag. Unless an argument has nargs set to argparse.REMAINDER,
@@ -94,7 +92,7 @@ def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
         return False
 
     # Flags have to start with a prefix character
-    if not token[0] in parser.prefix_chars:
+    if token[0] not in parser.prefix_chars:
         return False
 
     # If it looks like a negative number, it is not a flag unless there are negative-number-like flags
@@ -144,7 +142,6 @@ class _ArgumentState:
             self.max = self.action.nargs
 
 
-# noinspection PyProtectedMember
 class _UnfinishedFlagError(CompletionError):
     def __init__(self, flag_arg_state: _ArgumentState) -> None:
         """
@@ -171,7 +168,6 @@ class _NoResultsError(CompletionError):
         super().__init__(_build_hint(parser, arg_action), apply_style=False)
 
 
-# noinspection PyProtectedMember
 class ArgparseCompleter:
     """Automatic command line tab completion based on argparse parameters"""
 
@@ -273,10 +269,8 @@ class ArgparseCompleter:
             # Check if this action is in a mutually exclusive group
             for group in self._parser._mutually_exclusive_groups:
                 if arg_action in group._group_actions:
-
                     # Check if the group this action belongs to has already been completed
                     if group in completed_mutex_groups:
-
                         # If this is the action that completed the group, then there is no error
                         # since it's allowed to appear on the command line more than once.
                         completer_action = completed_mutex_groups[group]
@@ -307,7 +301,6 @@ class ArgparseCompleter:
         # Parse all but the last token
         #############################################################################################
         for token_index, token in enumerate(tokens[:-1]):
-
             # If we're in a positional REMAINDER arg, force all future tokens to go to that
             if pos_arg_state is not None and pos_arg_state.is_remainder:
                 consume_argument(pos_arg_state)
@@ -339,7 +332,6 @@ class ArgparseCompleter:
 
             # Check the format of the current token to see if it can be an argument's value
             if _looks_like_flag(token, self._parser) and not skip_remaining_flags:
-
                 # Check if there is an unfinished flag
                 if (
                     flag_arg_state is not None
@@ -484,7 +476,6 @@ class ArgparseCompleter:
 
         # Otherwise check if we have a positional to complete
         elif pos_arg_state is not None or remaining_positionals:
-
             # If we aren't current tracking a positional, then get the next positional arg to handle this token
             if pos_arg_state is None:
                 action = remaining_positionals.popleft()

cmd2/argparse_custom.py

@@ -101,7 +101,7 @@ dynamic. Therefore it is up to the developer to validate if the user has typed
 an acceptable value for these arguments.
 
 There are times when what's being tab completed is determined by a previous
-argument on the command line. In theses cases, ArgparseCompleter can pass a
+argument on the command line. In these cases, ArgparseCompleter can pass a
 dictionary that maps the command line tokens up through the one being completed
 to their argparse argument name. To receive this dictionary, your
 choices/completer function should have an argument called arg_tokens.
@@ -237,8 +237,6 @@ sub-parser from a sub-parsers group. See
 import argparse
 import re
 import sys
-
-# noinspection PyUnresolvedReferences,PyProtectedMember
 from argparse import (
     ONE_OR_MORE,
     ZERO_OR_MORE,
@@ -257,12 +255,14 @@ from typing import (
     List,
     NoReturn,
     Optional,
+    Protocol,
     Sequence,
     Set,
     Tuple,
     Type,
     Union,
     cast,
+    runtime_checkable,
 )
 
 from . import (
@@ -270,18 +270,6 @@ from . import (
     constants,
 )
 
-try:
-    from typing import (
-        Protocol,
-        runtime_checkable,
-    )
-except ImportError:
-    from typing_extensions import (  # type: ignore[assignment]
-        Protocol,
-        runtime_checkable,
-    )
-
-
 if TYPE_CHECKING:  # pragma: no cover
     from .argparse_completer import (
         ArgparseCompleter,
@@ -317,7 +305,6 @@ class CompletionItem(str):
     def __new__(cls, value: object, *args: Any, **kwargs: Any) -> 'CompletionItem':
         return super(CompletionItem, cls).__new__(cls, value)
 
-    # noinspection PyUnusedLocal
     def __init__(self, value: object, description: str = '', *args: Any) -> None:
         """
         CompletionItem Initializer
@@ -351,8 +338,7 @@ class ChoicesProviderFuncBase(Protocol):
     Function that returns a list of choices in support of tab completion
     """
 
-    def __call__(self) -> List[str]:
-        ...  # pragma: no cover
+    def __call__(self) -> List[str]: ...  # pragma: no cover
 
 
 @runtime_checkable
@@ -361,8 +347,7 @@ class ChoicesProviderFuncWithTokens(Protocol):
     Function that returns a list of choices in support of tab completion and accepts a dictionary of prior arguments.
     """
 
-    def __call__(self, *, arg_tokens: Dict[str, List[str]] = {}) -> List[str]:
-        ...  # pragma: no cover
+    def __call__(self, *, arg_tokens: Dict[str, List[str]] = {}) -> List[str]: ...  # pragma: no cover
 
 
 ChoicesProviderFunc = Union[ChoicesProviderFuncBase, ChoicesProviderFuncWithTokens]
@@ -380,8 +365,7 @@ class CompleterFuncBase(Protocol):
         line: str,
         begidx: int,
         endidx: int,
-    ) -> List[str]:
-        ...  # pragma: no cover
+    ) -> List[str]: ...  # pragma: no cover
 
 
 @runtime_checkable
@@ -399,8 +383,7 @@ class CompleterFuncWithTokens(Protocol):
         endidx: int,
         *,
         arg_tokens: Dict[str, List[str]] = {},
-    ) -> List[str]:
-        ...  # pragma: no cover
+    ) -> List[str]: ...  # pragma: no cover
 
 
 CompleterFunc = Union[CompleterFuncBase, CompleterFuncWithTokens]
@@ -745,11 +728,9 @@ def register_argparse_argument_parameter(param_name: str, param_type: Optional[T
 
 
 # Save original _ActionsContainer.add_argument so we can call it in our wrapper
-# noinspection PyProtectedMember
 orig_actions_container_add_argument = argparse._ActionsContainer.add_argument
 
 
-# noinspection PyProtectedMember
 def _add_argument_wrapper(
     self: argparse._ActionsContainer,
     *args: Any,
@@ -807,7 +788,6 @@ def _add_argument_wrapper(
         nargs_adjusted: Union[int, str, Tuple[int], Tuple[int, int], Tuple[int, float], None]
         # Check if nargs was given as a range
         if isinstance(nargs, tuple):
-
             # Handle 1-item tuple by setting max to INFINITY
             if len(nargs) == 1:
                 nargs = (nargs[0], constants.INFINITY)
@@ -885,7 +865,6 @@ def _add_argument_wrapper(
 
 
 # Overwrite _ActionsContainer.add_argument with our wrapper
-# noinspection PyProtectedMember
 setattr(argparse._ActionsContainer, 'add_argument', _add_argument_wrapper)
 
 ############################################################################################################
@@ -893,11 +872,9 @@ setattr(argparse._ActionsContainer, 'add_argument', _add_argument_wrapper)
 ############################################################################################################
 
 # Save original ArgumentParser._get_nargs_pattern so we can call it in our wrapper
-# noinspection PyProtectedMember
 orig_argument_parser_get_nargs_pattern = argparse.ArgumentParser._get_nargs_pattern
 
 
-# noinspection PyProtectedMember
 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]
@@ -919,18 +896,15 @@ def _get_nargs_pattern_wrapper(self: argparse.ArgumentParser, action: argparse.A
 
 
 # Overwrite ArgumentParser._get_nargs_pattern with our wrapper
-# noinspection PyProtectedMember
 setattr(argparse.ArgumentParser, '_get_nargs_pattern', _get_nargs_pattern_wrapper)
 
 
 ############################################################################################################
 # Patch ArgumentParser._match_argument with our wrapper to support nargs ranges
 ############################################################################################################
-# noinspection PyProtectedMember
 orig_argument_parser_match_argument = argparse.ArgumentParser._match_argument
 
 
-# noinspection PyProtectedMember
 def _match_argument_wrapper(self: argparse.ArgumentParser, action: argparse.Action, arg_strings_pattern: str) -> int:
     # Wrapper around ArgumentParser._match_argument behavior to support nargs ranges
     nargs_pattern = self._get_nargs_pattern(action)
@@ -946,7 +920,6 @@ def _match_argument_wrapper(self: argparse.ArgumentParser, action: argparse.Acti
 
 
 # Overwrite ArgumentParser._match_argument with our wrapper
-# noinspection PyProtectedMember
 setattr(argparse.ArgumentParser, '_match_argument', _match_argument_wrapper)
 
 
@@ -960,7 +933,6 @@ setattr(argparse.ArgumentParser, '_match_argument', _match_argument_wrapper)
 ATTR_AP_COMPLETER_TYPE = 'ap_completer_type'
 
 
-# noinspection PyPep8Naming
 def _ArgumentParser_get_ap_completer_type(self: argparse.ArgumentParser) -> Optional[Type['ArgparseCompleter']]:
     """
     Get the ap_completer_type attribute of an argparse ArgumentParser.
@@ -978,7 +950,6 @@ def _ArgumentParser_get_ap_completer_type(self: argparse.ArgumentParser) -> Opti
 setattr(argparse.ArgumentParser, 'get_ap_completer_type', _ArgumentParser_get_ap_completer_type)
 
 
-# noinspection PyPep8Naming
 def _ArgumentParser_set_ap_completer_type(self: argparse.ArgumentParser, ap_completer_type: Type['ArgparseCompleter']) -> None:
     """
     Set the ap_completer_type attribute of an argparse ArgumentParser.
@@ -999,7 +970,6 @@ setattr(argparse.ArgumentParser, 'set_ap_completer_type', _ArgumentParser_set_ap
 ############################################################################################################
 # Patch ArgumentParser._check_value to support CompletionItems as choices
 ############################################################################################################
-# noinspection PyPep8Naming
 def _ArgumentParser_check_value(self: argparse.ArgumentParser, action: argparse.Action, value: Any) -> None:
     """
     Custom override of ArgumentParser._check_value that supports CompletionItems as choices.
@@ -1032,7 +1002,7 @@ setattr(argparse.ArgumentParser, '_check_value', _ArgumentParser_check_value)
 # Patch argparse._SubParsersAction to add remove_parser function
 ############################################################################################################
 
-# noinspection PyPep8Naming,PyProtectedMember
+
 def _SubParsersAction_remove_parser(self: argparse._SubParsersAction, name: str) -> None:  # type: ignore
     """
     Removes a sub-parser from a sub-parsers group. Used to remove subcommands from a parser.
@@ -1061,7 +1031,6 @@ def _SubParsersAction_remove_parser(self: argparse._SubParsersAction, name: str)
             del self._name_parser_map[cur_name]
 
 
-# noinspection PyProtectedMember
 setattr(argparse._SubParsersAction, 'remove_parser', _SubParsersAction_remove_parser)
 
 
@@ -1073,11 +1042,9 @@ setattr(argparse._SubParsersAction, 'remove_parser', _SubParsersAction_remove_pa
 ############################################################################################################
 
 
-# noinspection PyCompatibility,PyShadowingBuiltins
 class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
     """Custom help formatter to configure ordering of help text"""
 
-    # noinspection PyProtectedMember
     def _format_usage(
         self,
         usage: Optional[str],
@@ -1117,20 +1084,19 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
 
             # build full usage string
             format = self._format_actions_usage
-            action_usage = format(required_options + optionals + positionals, groups)
+            action_usage = format(required_options + optionals + positionals, groups)  # type: ignore[arg-type]
             usage = ' '.join([s for s in [prog, action_usage] if s])
 
             # wrap the usage parts if it's too long
             text_width = self._width - self._current_indent
             if len(prefix) + len(usage) > text_width:
-
                 # Begin cmd2 customization
 
                 # break usage into wrappable parts
                 part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
-                req_usage = format(required_options, groups)
-                opt_usage = format(optionals, groups)
-                pos_usage = format(positionals, groups)
+                req_usage = format(required_options, groups)  # type: ignore[arg-type]
+                opt_usage = format(optionals, groups)  # type: ignore[arg-type]
+                pos_usage = format(positionals, groups)  # type: ignore[arg-type]
                 req_parts = re.findall(part_regexp, req_usage)
                 opt_parts = re.findall(part_regexp, opt_usage)
                 pos_parts = re.findall(part_regexp, pos_usage)
@@ -1141,7 +1107,6 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
                 # End cmd2 customization
 
                 # helper for wrapping lines
-                # noinspection PyMissingOrEmptyDocstring,PyShadowingNames
                 def get_lines(parts: List[str], indent: str, prefix: Optional[str] = None) -> List[str]:
                     lines: List[str] = []
                     line: List[str] = []
@@ -1224,7 +1189,6 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
                 return ', '.join(action.option_strings) + ' ' + args_string
             # End cmd2 customization
 
-    # noinspection PyMethodMayBeStatic
     def _determine_metavar(
         self,
         action: argparse.Action,
@@ -1249,7 +1213,6 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
     ) -> Callable[[int], Tuple[str, ...]]:
         metavar = self._determine_metavar(action, default_metavar)
 
-        # noinspection PyMissingOrEmptyDocstring
         def format(tuple_size: int) -> Tuple[str, ...]:
             if isinstance(metavar, tuple):
                 return metavar
@@ -1258,7 +1221,6 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
 
         return format
 
-    # noinspection PyProtectedMember
     def _format_args(self, action: argparse.Action, default_metavar: Union[str, Tuple[str, ...]]) -> str:
         """Customized to handle ranged nargs and make other output less verbose"""
         metavar = self._determine_metavar(action, default_metavar)
@@ -1287,7 +1249,6 @@ class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
         return super()._format_args(action, default_metavar)  # type: ignore[arg-type]
 
 
-# noinspection PyCompatibility
 class Cmd2ArgumentParser(argparse.ArgumentParser):
     """Custom ArgumentParser class that improves error and help output"""
 
@@ -1332,7 +1293,6 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
         self.set_ap_completer_type(ap_completer_type)  # type: ignore[attr-defined]
 
-    # noinspection PyProtectedMember
     def add_subparsers(self, **kwargs: Any) -> argparse._SubParsersAction:  # type: ignore
         """
         Custom override. Sets a default title if one was not given.
@@ -1361,7 +1321,6 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         formatted_message = ansi.style_error(formatted_message)
         self.exit(2, f'{formatted_message}\n\n')
 
-    # noinspection PyProtectedMember
     def format_help(self) -> str:
         """Copy of format_help() from argparse.ArgumentParser with tweaks to separately display required parameters"""
         formatter = self._get_formatter()

cmd2/clipboard.py

@@ -2,29 +2,10 @@
 """
 This module provides basic ability to copy from and paste to the clipboard/pastebuffer.
 """
-from typing import (
-    cast,
-)
 
-import pyperclip  # type: ignore[import]
-
-# noinspection PyProtectedMember
+import typing
 
-# Can we access the clipboard?  Should always be true on Windows and Mac, but only sometimes on Linux
-# noinspection PyBroadException
-try:
-    # Try getting the contents of the clipboard
-    _ = pyperclip.paste()
-
-# pyperclip raises at least the following types of exceptions. To be safe, just catch all Exceptions.
-#   FileNotFoundError on Windows Subsystem for Linux (WSL) when Windows paths are removed from $PATH
-#   ValueError for headless Linux systems without Gtk installed
-#   AssertionError can be raised by paste_klipper().
-#   PyperclipException for pyperclip-specific exceptions
-except Exception:
-    can_clip = False
-else:
-    can_clip = True
+import pyperclip  # type: ignore[import]
 
 
 def get_paste_buffer() -> str:
@@ -32,7 +13,7 @@ def get_paste_buffer() -> str:
 
     :return: contents of the clipboard
     """
-    pb_str = cast(str, pyperclip.paste())
+    pb_str = typing.cast(str, pyperclip.paste())
     return pb_str