cmd2 2.4.3__tar.gz → 2.5.0__tar.gz

cmd2-2.5.0/.readthedocs.yaml

@@ -0,0 +1,34 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+  # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs
+  # builder: "dirhtml"
+  # Fail on all warnings to avoid broken references
+  # fail_on_warning: true
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#   - pdf
+#   - epub
+formats: all
+
+# Optional but recommended, declare the Python requirements required to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

{cmd2-2.4.3 → cmd2-2.5.0}/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 2.5.0 (October 23, 2024)
+* Breaking Change
+  * `cmd2` 2.5 supports Python 3.8+ (removed support for Python 3.6 and 3.7)
+* Bug Fixes
+  * Fixed issue where persistent history file was not saved upon SIGHUP and SIGTERM signals.
+  * Multiline commands are no longer fragmented in up-arrow history.
+  * Fixed bug where `async_alert()` overwrites readline's incremental and non-incremental search prompts.
+    * This fix introduces behavior where an updated prompt won't display after an aborted search
+      until a user presses Enter. See [async_printing.py](https://github.com/python-cmd2/cmd2/blob/master/examples/async_printing.py)
+      example for how to handle this case using `Cmd.need_prompt_refresh()` and `Cmd.async_refresh_prompt()`.
+* Enhancements
+  * Removed dependency on `attrs` and replaced with [dataclasses](https://docs.python.org/3/library/dataclasses.html)
+  * add `allow_clipboard` initialization parameter and attribute to disable ability to
+    add output to the operating system clipboard
+  * Updated unit tests to be Python 3.13 compliant.
+  * Fall back to bz2 compression of history file when lzma is not installed.
+  * Added settable called `scripts_add_to_history` which determines whether scripts and pyscripts
+    add commands to history.
+* Deletions (potentially breaking changes)
+  * Removed `apply_style` from `Cmd.pwarning()`.
+
 ## 2.4.3 (January 27, 2023)
 * Bug Fixes
   * Fixed ValueError caused when passing `Cmd.columnize()` strings wider than `display_width`.
@@ -84,7 +105,7 @@
   * Added `ap_completer_type` keyword arg to `Cmd2ArgumentParser.__init__()` which saves a call
     to `set_ap_completer_type()`. This keyword will also work with `add_parser()` when creating subcommands
     if the base command's parser is a `Cmd2ArgumentParser`.
-  * New function `register_argparse_argument_parameter()` allows developers to specify custom 
+  * New function `register_argparse_argument_parameter()` allows developers to specify custom
     parameters to be passed to the argparse parser's `add_argument()` method. These parameters will
     become accessible in the resulting argparse Action object when modifying `ArgparseCompleter` behavior.
   * Using `SimpleTable` in the output for the following commands to improve appearance.
@@ -257,12 +278,12 @@
 
 ## 1.3.7 (August 27, 2020)
 * Bug Fixes
-    * Fixes an issue introduced in 1.3.0 with processing command strings containing terminator/separator 
+    * Fixes an issue introduced in 1.3.0 with processing command strings containing terminator/separator
       character(s) that are manually passed to a command that uses argparse.
 
 ## 1.3.6 (August 27, 2020)
 * Breaking changes
-    * The functions cmd2 adds to Namespaces (`get_statement()` and `get_handler()`) are now 
+    * The functions cmd2 adds to Namespaces (`get_statement()` and `get_handler()`) are now
     `Cmd2AttributeWrapper` objects named `cmd2_statement` and `cmd2_handler`. This makes it
     easy to filter out which attributes in an `argparse.Namespace` were added by `cmd2`.
 * Deprecations
@@ -288,7 +309,7 @@
 * Breaking changes
     * CommandSet command functions (do_, complete_, help_) will no longer have the cmd2 app
       passed in as the first parameter after `self` since this is already a class member.
-    * Renamed `install_command_set()` and `uninstall_command_set()` to `register_command_set()` and 
+    * Renamed `install_command_set()` and `uninstall_command_set()` to `register_command_set()` and
       `unregister_command_set()` for better name consistency.
 * Bug Fixes
     * Fixed help formatting bug in `Cmd2ArgumentParser` when `metavar` is a tuple
@@ -298,8 +319,8 @@
     * Removed explicit type hints that fail due to a bug in 3.5.2 favoring comment-based hints instead
     * When passing a ns_provider to an argparse command, will now attempt to resolve the correct
       CommandSet instance for self. If not, it'll fall back and pass in the cmd2 app
-* Other 
-    * Added missing doc-string for new cmd2.Cmd __init__ parameters 
+* Other
+    * Added missing doc-string for new cmd2.Cmd __init__ parameters
       introduced by CommandSet enhancement
 
 ## 1.3.2 (August 10, 2020)
@@ -314,8 +335,8 @@
 ## 1.3.1 (August 6, 2020)
 * Bug Fixes
     * Fixed issue determining whether an argparse completer function required a reference to a containing
-      CommandSet. Also resolves issues determining the correct CommandSet instance when calling the argparse 
-      argument completer function.  Manifested as a TypeError when using `cmd2.Cmd.path_complete` as a completer 
+      CommandSet. Also resolves issues determining the correct CommandSet instance when calling the argparse
+      argument completer function.  Manifested as a TypeError when using `cmd2.Cmd.path_complete` as a completer
       for an argparse-based command defined in a CommandSet
 
 ## 1.3.0 (August 4, 2020)
@@ -324,7 +345,7 @@
       with your cmd2 application.
 * Other
     * Marked with_argparser_and_unknown_args pending deprecation and consolidated implementation into
-      with_argparser 
+      with_argparser
 
 ## 1.2.1 (July 14, 2020)
 * Bug Fixes
@@ -332,7 +353,7 @@
 
 ## 1.2.0 (July 13, 2020)
 * Bug Fixes
-    * Fixed `typing` module compatibility issue with Python 3.5 prior to 3.5.4 
+    * Fixed `typing` module compatibility issue with Python 3.5 prior to 3.5.4
 * Enhancements
     * Switched to getting version using `importlib.metadata` instead of using `pkg_resources`
         * Improves `cmd2` application launch time on systems that have a lot of Python packages on `sys.path`
@@ -341,7 +362,7 @@
 ## 1.1.0 (June 6, 2020)
 * Bug Fixes
     * Fixed issue where subcommand usage text could contain a subcommand alias instead of the actual name
-    * Fixed bug in `ArgparseCompleter` where `fill_width` could become negative if `token_width` was large 
+    * Fixed bug in `ArgparseCompleter` where `fill_width` could become negative if `token_width` was large
       relative to the terminal width.
 * Enhancements
     * Made `ipy` consistent with `py` in the following ways
@@ -365,7 +386,7 @@
           after parsing fails, just return instead of raising an exception.
     * Added explicit handling of `SystemExit`. If a command raises this exception, the command loop will be
       gracefully stopped.
-    
+
 ## 1.0.2 (April 06, 2020)
 * Bug Fixes
     * Ctrl-C now stops a running text script instead of just the current `run_script` command
@@ -388,9 +409,9 @@
 * Bug Fixes
     * Corrected issue where the actual new value was not always being printed in do_set. This occurred in cases where
       the typed value differed from what the setter had converted it to.
-    * Fixed bug where ANSI style sequences were not correctly handled in `utils.truncate_line()`. 
+    * Fixed bug where ANSI style sequences were not correctly handled in `utils.truncate_line()`.
     * Fixed bug where pyscripts could edit `cmd2.Cmd.py_locals` dictionary.
-    * Fixed bug where cmd2 set `sys.path[0]` for a pyscript to cmd2's working directory instead of the 
+    * Fixed bug where cmd2 set `sys.path[0]` for a pyscript to cmd2's working directory instead of the
     script file's directory.
     * Fixed bug where `sys.path` was not being restored after a pyscript ran.
 * Enhancements
@@ -704,7 +725,7 @@
 * Enhancements
     * Added ability to include command name placeholders in the message printed when trying to run a disabled command.
         * See docstring for ``disable_command()`` or ``disable_category()`` for more details.
-    * Added instance attributes to customize error messages without having to override methods. Theses messages can
+    * Added instance attributes to customize error messages without having to override methods. These messages can
     also be colored.
         * `help_error` - the error that prints when no help information can be found
         * `default_error` - the error that prints when a non-existent command is run
@@ -841,7 +862,7 @@
     * Aliases are now sorted alphabetically
     * The **set** command now tab completes settable parameter names
     * Added ``async_alert``, ``async_update_prompt``, and ``set_window_title`` functions
-        * These allow you to provide feedback to the user in an asychronous fashion, meaning alerts can
+        * These allow you to provide feedback to the user in an asynchronous fashion, meaning alerts can
         display when the user is still entering text at the prompt. See [async_printing.py](https://github.com/python-cmd2/cmd2/blob/master/examples/async_printing.py)
         for an example.
     * Cross-platform colored output support
@@ -941,7 +962,7 @@
     * New pyscript approach that provides a pythonic interface to commands in the cmd2 application.
     * Switch command parsing from pyparsing to custom code which utilizes shlex.
         * The object passed to do_* methods has changed. It no longer is the pyparsing object, it's a new Statement object, which is a subclass of ``str``. The statement object has many attributes which give you access to various components of the parsed input. If you were using anything but the string in your do_* methods, this change will require you to update your code.
-        * ``commentGrammers`` is no longer supported or available. Comments are C-style or python style.
+        * ``commentGrammars`` is no longer supported or available. Comments are C-style or python style.
         * Input redirection no longer supported. Use the load command instead.
         * ``multilineCommand`` attribute is ``now multiline_command``
         * ``identchars`` is now ignored. The standardlibrary cmd uses those characters to split the first "word" of the input, but cmd2 hasn't used those for a while, and the new parsing logic parses on whitespace, which has the added benefit of full unicode support, unlike cmd or prior versions of cmd2.

{cmd2-2.4.3 → cmd2-2.5.0}/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2008-2023 Catherine Devlin and others
+Copyright (c) 2008-2024 Catherine Devlin and others
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{cmd2-2.4.3/cmd2.egg-info → cmd2-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cmd2
-Version: 2.4.3
+Version: 2.5.0
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Home-page: https://github.com/python-cmd2/cmd2
 Author: Catherine Devlin
@@ -16,17 +16,19 @@ Classifier: Intended Audience :: System Administrators
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: test
 Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: test
 Provides-Extra: validate
 License-File: LICENSE
 
@@ -40,7 +42,7 @@ License-File: LICENSE
 
 
 <p align="center">
-  <a href="#the-developers-toolbox">Develper's Toolbox</a> •
+  <a href="#the-developers-toolbox">Developer's Toolbox</a> •
   <a href="#philosophy">Philosophy</a> •
   <a href="#installation">Installation</a> •
   <a href="#documentation">Documentation</a> •
@@ -64,14 +66,14 @@ The developers toolbox
 ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
 
 
-When creating solutions developers have no shortage of tools to create rich and smart user interfaces. 
-System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall. 
-Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly. 
-On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality. 
+When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
+System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
+Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
+On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality.
 The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger systems.
-`cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems. 
+`cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems.
 
-The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion. 
+The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
 When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
 
 * Tab Completion
@@ -110,7 +112,7 @@ On all operating systems, the latest stable version of `cmd2` can be installed u
 pip install -U cmd2
 ```
 
-cmd2 works with Python 3.6+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
+cmd2 works with Python 3.8+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
 
 For information on other installation options, see
 [Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
@@ -129,7 +131,7 @@ The best way to learn the cmd2 api is to delve into the example applications loc
 Tutorials
 ---------
 
-* PyOhio 2019 presentation: 
+* PyOhio 2019 presentation:
     * [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
     * [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
     * [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
@@ -193,6 +195,4 @@ Projects using cmd2
 Possibly defunct but still good examples
 
 * [JSShell](https://github.com/Den1al/JSShell)
-* [FLASHMINGO](https://github.com/fireeye/flashmingo) 
-
-
+* [FLASHMINGO](https://github.com/fireeye/flashmingo)

cmd2-2.5.0/Pipfile

@@ -0,0 +1,33 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[packages]
+pyperclip = "*"
+setuptools = "*"
+wcwidth = "*"
+
+[dev-packages]
+build = "*"
+cmd2 = { editable = true, path = "." }
+cmd2_ext_test = { editable = true, path = "plugins/ext_test" }
+codecov = "*"
+doc8 = "*"
+gnureadline = { version = "*", sys_platform = "== 'darwin'" }
+invoke = "*"
+ipython = "*"
+mypy = "*"
+pyreadline3 = { version = ">=3.4", sys_platform = "== 'win32'" }
+pytest = "*"
+pytest-cov = "*"
+pytest-mock = "*"
+ruff = "*"
+setuptools-scm = "*"
+sphinx = "*"
+sphinx-autobuild = "*"
+sphinx-rtd-theme = "*"
+twine = ">=1.11"
+
+[pipenv]
+allow_prereleases = true

{cmd2-2.4.3 → cmd2-2.5.0}/README.md

@@ -8,7 +8,7 @@
 
 
 <p align="center">
-  <a href="#the-developers-toolbox">Develper's Toolbox</a> •
+  <a href="#the-developers-toolbox">Developer's Toolbox</a> •
   <a href="#philosophy">Philosophy</a> •
   <a href="#installation">Installation</a> •
   <a href="#documentation">Documentation</a> •
@@ -32,14 +32,14 @@ The developers toolbox
 ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
 
 
-When creating solutions developers have no shortage of tools to create rich and smart user interfaces. 
-System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall. 
-Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly. 
-On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality. 
+When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
+System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
+Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
+On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality.
 The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger systems.
-`cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems. 
+`cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems.
 
-The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion. 
+The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
 When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
 
 * Tab Completion
@@ -78,7 +78,7 @@ On all operating systems, the latest stable version of `cmd2` can be installed u
 pip install -U cmd2
 ```
 
-cmd2 works with Python 3.6+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
+cmd2 works with Python 3.8+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
 
 For information on other installation options, see
 [Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
@@ -97,7 +97,7 @@ The best way to learn the cmd2 api is to delve into the example applications loc
 Tutorials
 ---------
 
-* PyOhio 2019 presentation: 
+* PyOhio 2019 presentation:
     * [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
     * [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
     * [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
@@ -161,4 +161,4 @@ Projects using cmd2
 Possibly defunct but still good examples
 
 * [JSShell](https://github.com/Den1al/JSShell)
-* [FLASHMINGO](https://github.com/fireeye/flashmingo) 
+* [FLASHMINGO](https://github.com/fireeye/flashmingo)

{cmd2-2.4.3 → cmd2-2.5.0}/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-2.4.3 → cmd2-2.5.0}/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-2.4.3 → cmd2-2.5.0}/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()