cmd2

• Fixed bug where setting always_show_hint=True did not show a hint when completing Settables
• Fixed bug in editor detection logic on Linux systems that do not have which
• Fixed bug in table creator where column headers with tabs would result in an incorrect width calculation
• Fixed FileNotFoundError which occurred when running history --clear and no history file existed.

• Added silent_startup_script option to cmd2.Cmd.__init__(). If True, then the startup script's output will be suppressed. Anything written to stderr will still display.
• cmd2 now uses pyreadline3 when running Python 3.8 or greater on Windows

• This is the last release planned to support Python 3.5

• Fixed tab completion crash on Windows

• Changed how multiline doc string help is formatted to match style of other help messages

• Fixed issue where quoted redirectors and terminators in aliases and macros were not being restored when read from a startup script.
• Fixed issue where instantiating more than one cmd2-based class which uses the @as_subcommand_to decorator resulted in duplicated help text in the base command the subcommands belong to.

• Added user-settable option called always_show_hint. If True, then tab completion hints will always display even when tab completion suggestions print. Arguments whose help or hint text is suppressed will not display hints even when this setting is True.
• argparse tab completion now groups flag names which run the same action. Optional flags are wrapped in brackets like it is done in argparse usage text.
• default category decorators are now heritable by default and will propagate the category down the class hierarchy until overridden. There's a new optional flag to set heritable to false.
• Added --silent flag to alias/macro create. If used, then no confirmation message will be printed when aliases and macros are created or overwritten.
• Added --with_silent flag to alias/macro list. Use this option when saving to a startup script that should silently create aliases and macros.

• Fixed issue where flag names weren't always sorted correctly in argparse tab completion

• CommandSet.on_unregister() is now called as first step in unregistering a CommandSet and not the last. CommandSet.on_unregistered() is now the last step.

• Added CommandSet.on_registered(). This is called by cmd2.Cmd after a CommandSet is registered and all its commands have been added to the CLI.
• Added CommandSet.on_unregistered(). This is called by cmd2.Cmd after a CommandSet is unregistered and all its commands have been removed from the CLI.

• Fixed issue where subcommand added with @as_subcommand_to decorator did not display help when called with -h/--help.

• add_help=False no longer has to be passed to parsers used in @as_subcommand_to decorator. Only pass this if your subcommand should not have the -h/--help help option (as stated in argparse documentation).

• 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.

• 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.

• Namespace.__statement__ will be removed in cmd2 2.0.0. Use Namespace.cmd2_statement.get() going forward.

• Fixed RecursionError when printing an argparse.Namespace caused by custom attribute cmd2 was adding

• Added get_statement() function to argparse.Namespace which returns __statement__ attribute

• Fixed AttributeError when CommandSet that uses as_subcommand_to decorator is loaded during cmd2.Cmd.__init__().

• Improved exception messages when using mock without spec=True. See testing documentation for more details on testing cmd2-based applications with mock.

• 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 unregister_command_set() for better name consistency.

• Fixed help formatting bug in Cmd2ArgumentParser when metavar is a tuple
• Fixed tab completion bug when using CompletionItem on an argument whose metavar is a tuple
• Added explicit testing against python 3.5.2 for Ubuntu 16.04, and 3.5.3 for Debian 9
• Added fallback definition of typing.Deque (taken from 3.5.4)
• 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

• Added missing doc-string for new cmd2.Cmd init parameters introduced by CommandSet enhancement

• Fixed prog value of subcommands added with as_subcommand_to() decorator.
• Fixed missing settings in subcommand parsers created with as_subcommand_to() decorator. These settings include things like description and epilog text.
• Fixed issue with CommandSet auto-discovery only searching direct sub-classes

• Added functions to fetch registered CommandSets by type and command name

• 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 for an argparse-based command defined in a CommandSet

• Added CommandSet - Enables defining a separate loadable module of commands to register/unregister with your cmd2 application.

• Marked with_argparser_and_unknown_args pending deprecation and consolidated implementation into with_argparser

• Relax minimum version of importlib-metadata to >= 1.6.0 when using Python < 3.8

• Fixed typing module compatibility issue with Python 3.5 prior to 3.5.4

• 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
  • Added dependency on importlib_metadata when running on versions of Python prior to 3.8

• 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 relative to the terminal width.

• Made ipy consistent with py in the following ways
  • ipy returns whether any of the commands run in it returned True to stop command loop
  • Cmd.in_pyscript() returns True while in ipy.
  • Starting ipy when Cmd.in_pyscript() is already True is not allowed.
• with_argument_list, with_argparser, and with_argparser_and_unknown_args wrappers now pass kwargs through to their wrapped command function.
• Added table_creator module for creating richly formatted tables. This module is in beta and subject to change.
  • See table_creation documentation for an overview.
  • See table_creation.py for an example.
• Added the following exceptions to the public API
  • SkipPostcommandHooks - 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.
  • Cmd2ArgparseError - 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.
• Added explicit handling of SystemExit. If a command raises this exception, the command loop will be gracefully stopped.

• Ctrl-C now stops a running text script instead of just the current run_script command

• do_shell() now saves the return code of the command it runs in self.last_result for use in pyscripts

• Fixed issue where postcmd hooks were running after an argparse exception in a command.

• The documentation at cmd2.rftd.io received a major overhaul

• Moved categorize utility function from * *decorators** module to **utils** module

• Now that the 1.0 release is out, cmd2 intends to follow Semantic Versioning

• 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 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 script file's directory.
• Fixed bug where sys.path was not being restored after a pyscript ran.

• Renamed set command's -l/--long flag to -v/--verbose for consistency with help and history commands.
• Setting the following pyscript variables:
  • __name__: main
  • __file__: script path (as typed, ~ will be expanded)
• Only tab complete after redirection tokens if redirection is allowed
• Made CompletionError exception available to non-argparse tab completion
• Added apply_style to CompletionError initializer. It defaults to True, but can be set to False if you don't want the error text to have ansi.style_error() applied to it when printed.

• Removed undocumented py run command since it was replaced by run_pyscript a while ago
• Renamed AutoCompleter to ArgparseCompleter for clarity
• Custom EmptyStatement exception is no longer part of the documented public API

• This is a beta release leading up to the 1.0.0 release
• We intend no more breaking changes prior to 1.0.0
  • Just bug fixes, documentation updates, and enhancements

• Changed the default help text to make help -v more discoverable
• set command now supports tab completion of values
• Added add_settable() and remove_settable() convenience methods to update self.settable dictionary
• Added convenience ansi.fg and ansi.bg enums of foreground and background colors
  • ansi.style() fg argument can now either be of type str or ansi.fg
  • ansi.style() bg argument can now either be of type str or ansi.bg
  • This supports IDE auto-completion of color names
  • The enums also support
    • f-strings and format() calls (e.g. "{}hello{}".format(fg.blue, fg.reset))
    • string concatenation (e.g. fg.blue + "hello" + fg.reset)

• Renamed locals_in_py attribute of cmd2.Cmd to self_in_py
• The following public attributes of cmd2.Cmd are no longer settable at runtime by default:
  • continuation_prompt
  • self_in_py
  • prompt
• self.settable changed to self.settables
  • It is now a Dict[str, Settable] instead of Dict[str, str]
  • setting onchange callbacks have a new method signature and must be added to the Settable instance in order to be called
• Removed cast() utility function
• Removed ansi.FG_COLORS and ansi.BG_COLORS dictionaries
  • Replaced with ansi.fg and ansi.bg enums providing similar but improved functionality

• This is an alpha release leading up to the 1.0.0 release
• We intend no more breaking changes prior to 1.0.0
  • Just bug fixes, documentation updates, and enhancements

• Reduced what gets put in package downloadable from PyPI (removed irrelevant CI config files and such)

• Flushing stderr when setting the window title and printing alerts for better responsiveness in cases where stderr is not unbuffered.
• Added function to truncate a single line to fit within a given display width. cmd2.utils.truncate_line supports characters with display widths greater than 1 and ANSI style sequences.
• Added line truncation support to cmd2.utils text alignment functions.
• Added support for Python 3.9 alpha

• Fixed bug where startup script containing a single quote in its file name was incorrectly quoted
• Added missing implicit dependency on setuptools due to build with setuptools_scm

• Added dim text style support via style() function and ansi.INTENSITY_DIM setting.

• Renamed the following ansi members for accuracy in what types of ANSI escape sequences are handled
  • ansi.allow_ansi -> ansi.allow_style
  • ansi.ansi_safe_wcswidth() -> ansi.style_aware_wcswidth()
  • ansi.ansi_aware_write() -> ansi.style_aware_write()
• Renamed the following ansi members for clarification
  • ansi.BRIGHT -> ansi.INTENSITY_BRIGHT
  • ansi.NORMAL -> ansi.INTENSITY_NORMAL

• Fixed bug where a redefined ansi.style_error was not being used in all cmd2 files

• Enabled line buffering when redirecting output to a file
• Added align_left(), align_center(), and align_right() to utils.py. All 3 of these functions support ANSI escape sequences and characters with display widths greater than 1. They wrap align_text() which is also in utils.py.

• Fixed bug where pipe processes were not being stopped by Ctrl-C
• Added exception handling to account for non-standard Python environments in which readline is not loaded dynamically from a shared library file

• Added read_input() function that is used to read from stdin. Unlike the Python built-in input(), it also has an argument to disable tab completion while input is being entered.
• Added capability to override the argument parser class used by cmd2 built-in commands. See override_parser.py example for more details.
• Added end argument to pfeedback() to be consistent with the other print functions like poutput().
• Added apply_style to pwarning().

• For consistency between all the print functions:
  • Made end and chop keyword-only arguments of ppaged()
  • end is always added to message in ppaged()

• Fixed bug where setting use_ipython to False removed ipy command from the entire cmd2.Cmd class instead of just the instance being created
• Fix bug where cmd2 ran 'stty sane' command when stdin was not a terminal

• Send all startup script paths to run_script. Previously we didn't do this if the file was empty, but that showed no record of the run_script command in history.
• Made it easier for developers to override edit command by having do_history no longer call do_edit. This also removes the need to exclude edit command from history list.
• It is no longer necessary to set the prog attribute of an argparser with subcommands. cmd2 now automatically sets the prog value of it and all its subparsers so that all usage statements contain the top level command name and not sys.argv[0].

• Some constants were moved from cmd2.py to constants.py
• cmd2 command decorators were moved to decorators.py. If you were importing them via cmd2's __init__.py, then there will be no issues.

• Fixed ValueError exception which could occur when an old format persistent history file is loaded with new cmd2

• Improved displaying multiline CompletionErrors by indenting all lines

• Fixed bug introduced in 0.9.17 where help functions for hidden and disabled commands were not being filtered out as help topics

• AutoCompleter now handles argparse's mutually exclusive groups. It will not tab complete flag names or positionals for already completed groups. It also will print an error if you try tab completing a flag's value if the flag belongs to a completed group.
• AutoCompleter now uses the passed-in parser's help formatter to generate hint text. This gives help and hint text for an argument consistent formatting.

• Fixed a bug when using WSL when all Windows paths have been removed from $PATH
• Fixed a bug when running a cmd2 application on Linux without Gtk libraries installed

• No longer treating empty text scripts as an error condition
• Allow dynamically extending a cmd2.Cmd object instance with a do_xxx method at runtime
• Choices/Completer functions can now be passed a dictionary that maps command-line tokens to their argparse argument. This is helpful when one argument determines what is tab completed for another argument. If these functions have an argument called arg_tokens, then AutoCompleter will automatically pass this dictionary to them.
• Added CompletionError class that can be raised during argparse-based tab completion and printed to the user
• Added the following convenience methods
  • Cmd.in_script() - return whether a text script is running
  • Cmd.in_pyscript() - return whether a pyscript is running

• Fixed inconsistent parsing/tab completion behavior based on the value of allow_redirection. This flag is only meant to be a security setting that prevents redirection of stdout and should not alter parsing logic.

• Raise TypeError if trying to set choices/completions on argparse action that accepts no arguments
• Create directory for the persistent history file if it does not already exist
• Added set_choices_function(), set_choices_method(), set_completer_function(), and set_completer_method() to support cases where this functionality needs to be added to an argparse action outside of the normal parser.add_argument() call.

• Aliases and macros can no longer have the same name as a command

• Fixed exception caused by tab completing after an invalid subcommand was entered
• Fixed bug where history -v was sometimes showing raw and expanded commands when they weren't different
• Fixed bug where multiline commands were having leading and ending spaces stripped. This would mess up quoted strings that crossed multiple lines.
• Fixed a bug when appending to the clipboard where contents were in reverse order
• Fixed issue where run_pyscript failed if the script's filename had 2 or more consecutive spaces
• Fixed issue where completer function of disabled command would still run

• Greatly simplified using argparse-based tab completion. The new interface is a complete overhaul that breaks the previous way of specifying completion and choices functions. See header of argparse_custom.py for more information.
• Enabled tab completion on multiline commands

• The following commands were renamed in the last release and have been removed in this release
  • load - replaced by run_script
  • _relative_load - replaced by _relative_run_script
  • pyscript - replaced by run_pyscript
• We apologize for any inconvenience, but the new names are more self-descriptive
  • Lots of end users were confused particularly about what exactly load should be loading

• Restored cmd2.Cmd.statement_parser to be a public attribute (no underscore)
  • Since it can be useful for creating post-parsing hooks
• Completely overhauled the interface for adding tab completion to argparse arguments. See enhancements for more details.
• ACArgumentParser is now called Cmd2ArgumentParser
• Moved basic_complete to utils.py
• Made optional arguments on the following completer methods keyword-only: delimiter_complete, flag_based_complete, index_based_complete, path_complete, shell_cmd_complete
• Renamed history option from --output-file to --output_file
• Renamed matches_sort_key to default_sort_key. This value determines the default sort ordering of string results like alias, command, category, macro, settable, and shortcut names. Unsorted tab completion results also are sorted with this key. Its default value (ALPHABETICAL_SORT_KEY) performs a case-insensitive alphabetical sort, but it can be changed to a natural sort by setting the value to NATURAL_SORT_KEY.
• StatementParser now expects shortcuts to be passed in as dictionary. This eliminates the step of converting the shortcuts dictionary into a tuple before creating StatementParser.
• Renamed Cmd.pyscript_name to Cmd.py_bridge_name
• Renamed Cmd.pystate to Cmd.py_locals
• Renamed PyscriptBridge to PyBridge

• Added support for and testing with Python 3.8, starting with 3.8 beta
• Improved information displayed during transcript testing
• Added ansi module with functions and constants to support ANSI escape sequences which are used for things like applying style to text
• Added support for applying styles (color, bold, underline) to text via style() function in ansi module
• Added default styles to ansi.py for printing success, warning. and error text. These are the styles used by cmd2 and can be overridden to match the color scheme of your application.
• Added ansi_aware_write() function to ansi module. This function takes into account the value of allow_ansi to determine if ANSI escape sequences should be stripped when not writing to a tty. See documentation for more information on the allow_ansi setting.

• Python 3.4 reached its end of life on March 18, 2019 and is no longer supported by cmd2
  • If you need to use Python 3.4, you should pin your requirements to use cmd2 0.9.13
• Made lots of changes to minimize the public API of the cmd2.Cmd class
  • Attributes and methods we do not intend to be public now all begin with an underscore
  • We make no API stability guarantees about these internal functions
• Split perror into 2 functions:
  • perror - print a message to sys.stderr
  • pexcept - print Exception message to sys.stderr. If debug is true, print exception traceback if one exists
• Signature of poutput and perror significantly changed
  • Removed color parameters color, err_color, and war_color from poutput and perror
    • See the docstrings of these methods or the cmd2 docs for more info on applying styles to output messages
  • end argument is now keyword-only and cannot be specified positionally
  • traceback_war no longer exists as an argument since it isn't needed now that perror and pexcept exist
• Moved cmd2.Cmd.colors to ansi.py and renamed it to allow_ansi. This is now an application-wide setting.
• Renamed the following constants and moved them to ansi.py
  • COLORS_ALWAYS --> ANSI_ALWAYS
  • COLORS_NEVER --> ANSI_NEVER
  • COLORS_TERMINAL --> ANSI_TERMINAL

• The following commands have been renamed. The old names will be supported until the next release.
  • load --> run_script
  • _relative_load --> _relative_run_script
  • pyscript --> run_pyscript

• Fixed issue where the wrong terminator was being appended by Statement.expanded_command_line()
• Fixed issue where aliases and macros could not contain terminator characters in their values
• History now shows what was typed for macros and not the resolved value by default. This is consistent with the behavior of aliases. Use the expanded or verbose arguments to history to see the resolved value for the macro.
• Fixed parsing issue in case where output redirection appears before a pipe. In that case, the pipe was given precedence even though it appeared later in the command.
• Fixed issue where quotes around redirection file paths were being lost in Statement.expanded_command_line()
• Fixed a bug in how line numbers were calculated for transcript testing
• Fixed issue where _cmdloop() suppressed exceptions by returning from within its finally code
• Fixed UnsupportedOperation on fileno error when a shell command was one of the commands run while generating a transcript
• Fixed bug where history was displaying expanded multiline commands when -x was not specified

• Added capability to chain pipe commands and redirect their output (e.g. !ls -l | grep user | wc -l > out.txt)
• pyscript limits a command's stdout capture to the same period that redirection does. Therefore output from a command's postparsing and finalization hooks isn't saved in the StdSim object.
• StdSim.buffer.write() now flushes when the wrapped stream uses line buffering and the bytes being written contain a newline or carriage return. This helps when pyscript is echoing the output of a shell command since the output will print at the same frequency as when the command is run in a terminal.
• ACArgumentParser no longer prints complete help text when a parsing error occurs since long help messages scroll the actual error message off the screen.
• Exceptions occurring in tab completion functions are now printed to stderr before returning control back to readline. This makes debugging a lot easier since readline suppresses these exceptions.
• Added support for custom Namespaces in the argparse decorators. See description of ns_provider argument for more information.
• Transcript testing now sets the exit_code returned from cmdloop based on Success/Failure
• The history of entered commands previously was saved using the readline persistence mechanism, and only persisted if you had readline installed. Now history is persisted independent of readline; user input from previous invocations of cmd2 based apps now shows in the history command.
• Text scripts now run immediately instead of adding their commands to cmdqueue. This allows easy capture of the entire script's output.
• Added member to CommandResult called stop which is the return value of onecmd_plus_hooks after it runs the given command line.

• Replaced unquote_redirection_tokens() with unquote_specific_tokens(). This was to support the fix that allows terminators in alias and macro values.
• Changed Statement.pipe_to to a string instead of a list
• preserve_quotes is now a keyword-only argument in the argparse decorators
• Refactored so that cmd2.Cmd.cmdloop() returns the exit_code instead of a call to sys.exit() It is now application developer's responsibility to treat the return value from cmdloop() accordingly
• Only valid commands are persistent in history between invocations of cmd2 based apps. Previously all user input was persistent in history. If readline is installed, the history available with the up and down arrow keys (readline history) may not match that shown in the history command, because history only tracks valid input, while readline history captures all input.
• History is now persisted in a binary format, not plain text format. Previous history files are destroyed on first launch of a cmd2 based app of version 0.9.13 or higher.
• HistoryItem class is no longer a subclass of str. If you are directly accessing the .history attribute of a cmd2 based app, you will need to update your code to use .history.get(1).statement.raw instead.
• Removed internally used eos command that was used to keep track of when a text script's commands ended
• Removed cmd2 member called _STOP_AND_EXIT since it was just a boolean value that should always be True
• Removed cmd2 member called _should_quit since PyBridge now handles this logic
• Removed support for cmd.cmdqueue
• allow_cli_args is now an argument to init instead of a cmd2 class member

• Python 3.4 reached its end of life on March 18, 2019
• This is the last release of cmd2 which will support Python 3.4

• Fixed a bug in how redirection and piping worked inside py or pyscript commands
• Fixed bug in async_alert where it didn't account for prompts that contained newline characters
• Fixed path completion case when CWD is just a slash. Relative path matches were incorrectly prepended with a slash.

• 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. 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
• The with_argparser decorators now add the Statement object created when parsing the command line to the argparse.Namespace object they pass to the do_* methods. It is stored in an attribute called __statement__. This can be useful if a command function needs to know the command line for things like logging.
• Added a -t option to the load command for automatically generating a transcript based on a script file
• When in a pyscript, the stdout and stderr streams of shell commands and processes being piped to are now captured and included in the CommandResult structure.

• The following commands now write to stderr instead of stdout when printing an error. This will make catching errors easier in pyscript. _ do_help() - when no help information can be found _ default() - in all cases since this is called when an invalid command name is run * _report_disabled_command_usage() - in all cases since this is called when a disabled command is run
• Removed *** from beginning of error messages printed by do_help() and default()
• Significantly refactored cmd.Cmd class so that all class attributes got converted to instance attributes, also:
  • Added allow_redirection, terminators, multiline_commands, and shortcuts as optional arguments to cmd2.Cmd.__init__()
  • A few instance attributes were moved inside StatementParser and properties were created for accessing them
• self.pipe_proc is now called self.cur_pipe_proc_reader and is a ProcReader class.
• Shell commands and commands being piped to while in a pyscript will function as if their output is going to a pipe and not a tty. This was necessary to be able to capture their output.
• Removed reserved_words class attribute due to lack of use
• Removed keywords instance attribute due to lack of use

• Fixed bug in how history command deals with multiline commands when output to a script
• Fixed a bug when the with_argument_list decorator is called with the optional preserve_quotes argument
• Fix bug in perror() where it would try to print an exception Traceback even if none existed

• Improvements to the history command
  • Simplified the display format and made it more similar to bash
  • Added -x, --expanded flag
    • output expanded commands instead of entered command (expands aliases, macros, and shortcuts)
  • Added -v, --verbose flag
    • display history and include expanded commands if they differ from the typed command
  • Added support for negative indices
• Added matches_sort_key to override the default way tab completion matches are sorted
• Added StdSim.pause_storage member which when True will cause StdSim to not save the output sent to it. See documentation for CommandResult in pyscript_bridge.py for reasons pausing the storage can be useful.
• Added ability to disable/enable individual commands and entire categories of commands. When a command is disabled, it will not show up in the help menu or tab complete. If a user tries to run the command or call help on it, a command-specific message supplied by the developer will be printed. The following commands were added to support this feature.
  • enable_command()
  • enable_category()
  • disable_command()
  • disable_category()

• Made cmd2_app a positional and required argument of AutoCompleter since certain functionality now requires that it can't be None.
• AutoCompleter no longer assumes CompletionItem results are sorted. Therefore you should follow the cmd2 convention of setting self.matches_sorted to True before returning the results if you have already sorted the CompletionItem list. Otherwise it will be sorted using self.matches_sort_key.
• Removed support for bash completion since this feature had slow performance. Also it relied on AutoCompleter which has since developed a dependency on cmd2 methods.
• Removed ability to call commands in pyscript as if they were functions (e.g. app.help()) in favor of only supporting one pyscript interface. This simplifies future maintenance.
• No longer supporting C-style comments. Hash (#) is the only valid comment marker.
• No longer supporting comments embedded in a command. Only command line input where the first non-whitespace character is a # will be treated as a comment. This means any # character appearing later in the command will be treated as a literal. The same applies to a # in the middle of a multiline command, even if it is the first character on a line. _ # this is a comment _ this # is not a comment

• Fixed unit test that hangs on Windows

• Fixed bug where the set command was not tab completing from the current settable dictionary.

• Changed edit command to use do_shell() instead of calling os.system()

• Fixed issue with echoing strings in StdSim. Because they were being sent to a binary buffer, line buffering was being ignored.

• Made quit() and exit() functions available to scripts run with pyscript. This allows those scripts to exit back to the console's prompt instead of exiting the whole application.

• Fixed bug when user chooses a zero or negative index when calling Cmd.select()
• Restored behavior where cmd_echo always starts as False in a py script. This was broken in 0.9.5.

• cmdloop now only attempts to register a custom signal handler for SIGINT if running in the main thread
• commands run as a result of default_to_shell being True now run via do_shell() and are saved to history.
• Added more tab completion to pyscript command.

• Deleted Cmd.colorize() and Cmd._colorcodes which were deprecated in 0.9.5
• Replaced dir_exe_only and dir_only flags in path_complete with optional path_filter function that is used to filter paths out of completion results.
• perror() no longer prepends "ERROR: " to the error message being printed

• Fixed bug introduced in 0.9.5 caused by backing up and restoring self.prompt in pseudo_raw_input. As part of this fix, continuation prompts will not be redrawn with async_update_prompt or async_alert.

• All platforms now depend on wcwidth to assist with asynchronous alerts.
• Macros now accept extra arguments when called. These will be tacked onto the resolved command.
• All cmd2 commands run via py now go through onecmd_plus_hooks.

• Fixed bug where get_all_commands could return non-callable attributes
• Fixed bug where alias command was dropping quotes around arguments
• Fixed bug where running help on argparse commands didn't work if they didn't support -h
• Fixed transcript testing bug where last command in transcript has no expected output
• Fixed bugs with how AutoCompleter and ArgparseFunctor handle argparse arguments with nargs=argparse.REMAINDER. Tab completion now correctly matches how argparse will parse the values. Command strings generated by ArgparseFunctor should now be compliant with how argparse expects REMAINDER arguments to be ordered.
• Fixed bugs with how AutoCompleter handles flag prefixes. It is no longer hard-coded to use '-' and will check against the prefix_chars in the argparse object. Also, single-character tokens that happen to be a prefix char are not treated as flags by argparse and AutoCompleter now matches that behavior.
• Fixed bug where AutoCompleter was not distinguishing between a negative number and a flag
• Fixed bug where AutoCompleter did not handle -- the same way argparse does (all args after -- are non-options)

• Added exit_code attribute of cmd2.Cmd class
  • Enables applications to return a non-zero exit code when exiting from cmdloop
• ACHelpFormatter now inherits from argparse.RawTextHelpFormatter to make it easier for formatting help/description text
• 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 asynchronous fashion, meaning alerts can display when the user is still entering text at the prompt. See async_printing.py for an example.
• Cross-platform colored output support
  • colorama gets initialized properly in Cmd.__init()
  • The Cmd.colors setting is no longer platform dependent and now has three values:
    • Terminal (default) - output methods do not strip any ANSI escape sequences when output is a terminal, but if the output is a pipe or a file the escape sequences are stripped
    • Always - output methods never strip ANSI escape sequences, regardless of the output destination
    • Never - output methods strip all ANSI escape sequences
• Added macro command to create macros, which are similar to aliases, but can take arguments when called
• All cmd2 command functions have been converted to use argparse.
• Renamed argparse_example.py to decorator_example.py to help clarify its intent

• Deprecated the built-in cmd2 support for colors including Cmd.colorize() and Cmd._colorcodes

• The preparse, postparsing_precmd, and postparsing_postcmd methods deprecated in the previous release have been deleted * The new application lifecycle hook system allows for registration of callbacks to be called at various points in the lifecycle and is more powerful and flexible than the previous system
• alias is now a command with subcommands to create, list, and delete aliases. Therefore its syntax has changed. All current alias commands in startup scripts or transcripts will break with this release.
• unalias was deleted since alias delete replaced it

• Fixed bug where preparse was not getting called
• Fixed bug in parsing of multiline commands where matching quote is on another line

• Improved implementation of lifecycle hooks to support a plugin framework, see docs/hooks.rst for details.
• New dependency on attrs third party module
• Added matches_sorted member to support custom sorting of tab completion matches
• Added tab_autocomp_dynamic.py example
  • Demonstrates updating the argparse object during init instead of during class construction

• Deprecated the following hook methods, see hooks.rst for full details:
  • cmd2.Cmd.preparse() - equivalent functionality available via cmd2.Cmd.register_postparsing_hook()
  • cmd2.Cmd.postparsing_precmd() - equivalent functionality available via cmd2.Cmd.register_postparsing_hook()
  • cmd2.Cmd.postparsing_postcmd() - equivalent functionality available via cmd2.Cmd.register_postcmd_hook()

• Fixed bug when StatementParser __init__() was called with terminators equal to None
• Fixed bug when Cmd.onecmd() was called with a raw str

• Added --clear flag to history command that clears both the command and readline history.

• The CmdResult helper class which was deprecated in the previous release has now been deleted
  • It has been replaced by the improved CommandResult class

• Fixed issue where piping and redirecting did not work correctly with paths that had spaces

• Added ability to print a header above tab completion suggestions using completion_header member
• Added pager and pager_chop attributes to the cmd2.Cmd class
  • pager defaults to less -RXF on POSIX and more on Windows
  • pager_chop defaults to less -SRXF on POSIX and more on Windows
• Added chop argument to cmd2.Cmd.ppaged() method for displaying output using a pager
  • If chop is False, then self.pager is used as the pager
  • Otherwise self.pager_chop is used as the pager
• Greatly improved the table_display.py example
  • Now uses the new tableformatter module which looks better than tabulate

• The CmdResult helper class is deprecated and replaced by the improved CommandResult class
  • CommandResult has the following attributes: stdout, stderr, and data
    • CmdResult had attributes of: out, err, war
  • CmdResult will be deleted in the next release

• fix packaging error for 0.8.x versions (yes we had to deploy a new version of the 0.9.x series to fix a packaging error with the 0.8.x version)

• Fixed extra slash that could print when tab completing users on Windows

• Prevent crashes that could occur attempting to open a file in non-existent directory or with very long filename

• display_matches is no longer restricted to delimited strings

• Commands using the @with_argparser_and_unknown_args were not correctly recognized when tab completing
• Fixed issue where completion display function was overwritten when a submenu quits
• Fixed AttributeError on Windows when running a select command cause by pyreadline not implementing remove_history_item

• Added warning about libedit variant of readline not being supported on macOS
• Added tab completion of alias names in value field of alias command
• Enhanced the py console in the following ways
  • Added tab completion of Python identifiers instead of cmd2 commands
  • Separated the py console history from the cmd2 history

Bug Fixes

• Fixed a bug with all argument decorators where the wrapped function wasn't returning a value and thus couldn't cause the cmd2 app to quit

Enhancements

• Added support for verbose help with -v where it lists a brief summary of what each command does
• Added support for categorizing commands into groups within the help menu
  • See the Grouping Commands section of the docs for more info
  • See help_categories.py for an example
• Tab completion of paths now supports ~user user path expansion
• Simplified implementation of various tab completion functions so they no longer require ctypes
• Expanded documentation of display_matches list to clarify its purpose. See cmd2.py for this documentation.
• Adding opening quote to tab completion if any of the completion suggestions have a space.

Python 2 EOL notice

• This is the last release where new features will be added to cmd2 for Python 2.7
• The 0.9.0 release of cmd2 will support Python 3.4+ only
• Additional 0.8.x releases may be created to supply bug fixes for Python 2.7 up until August 31, 2018
• After August 31, 2018 not even bug fixes will be provided for Python 2.7

• Fixed conditional dependency issue in setup.py that was in 0.8.3.

Bug Fixes

• Fixed help command not calling functions for help topics
• Fixed not being able to use quoted paths when redirecting with < and >

Enhancements

• Tab completion has been overhauled and now supports completion of strings with quotes and spaces.
• Tab completion will automatically add an opening quote if a string with a space is completed.
• Added delimiter_complete function for tab completing delimited strings
• Added more control over tab completion behavior including the following flags. The use of these flags is documented in cmd2.py
  • allow_appended_space
  • allow_closing_quote
• Due to the tab completion changes, non-Windows platforms now depend on wcwidth.
• An alias name can now match a command name.
• An alias can now resolve to another alias.

Attribute Changes (Breaks backward compatibility)

• exclude_from_help is now called hidden_commands since these commands are hidden from things other than help, including tab completion
  • This list also no longer takes the function names of commands (do_history), but instead uses the command names themselves (history)
• excludeFromHistory is now called exclude_from_history
• cmd_with_subs_completer() no longer takes an argument called base. Adding tab completion to subcommands has been simplified to declaring it in the subcommand parser's default settings. This easily allows arbitrary completers like path_complete to be used. See subcommands.py for an example of how to use tab completion in subcommands. In addition, the docstring for cmd_with_subs_completer() offers more details.