cmd2 3.0.0b2__tar.gz → 3.0.0rc1__tar.gz

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/.pre-commit-config.yaml

@@ -9,12 +9,12 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.13.0"
+    rev: "v0.13.2"
     hooks:
       - id: ruff-format
-        args: [--config=pyproject.toml]
+        args: [--config=ruff.toml]
       - id: ruff-check
-        args: [--config=pyproject.toml, --fix, --exit-non-zero-on-fix]
+        args: [--config=ruff.toml, --fix, --exit-non-zero-on-fix]
 
   - repo: https://github.com/pre-commit/mirrors-prettier
     rev: "v3.1.0"

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/CHANGELOG.md

@@ -1,4 +1,4 @@
-## 3.0.0 (TBD, 2025)
+## 3.0.0 (October TBD, 2025)
 
 ### Summary
 
@@ -52,6 +52,12 @@ time reading the [rich documentation](https://rich.readthedocs.io/).
     - Fixed a redirection bug where `cmd2` could unintentionally overwrite an application's
       `sys.stdout`
 
+- Migration Aids - these will help you iteratively migrate to `cmd2` 3.x in stages
+    - Published new [cmd2-ansi](https://pypi.org/project/cmd2-ansi/) module which is a backport of
+      the `cmd2.ansi` module present in `cmd2` 2.7.0
+    - Published new [cmd2-table](https://pypi.org/project/cmd2-table/) module which is a backport of
+      the `cmd2.table_creator` module present in `cmd2` 2.7.0
+
 ## 2.7.0 (June 30, 2025)
 
 - Enhancements

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/MANIFEST.in

@@ -1,4 +1,4 @@
-include LICENSE README.md CHANGELOG.md mkdocs.yml pyproject.toml tasks.py
+include LICENSE README.md CHANGELOG.md mkdocs.yml pyproject.toml ruff.toml tasks.py
 recursive-include examples *
 recursive-include tests *
 recursive-include docs *

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.0.0b2
+Version: 3.0.0rc1
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -58,7 +58,8 @@ when using cmd.
 
 > :warning: **cmd2 is now "feature complete" for the `2.x` branch and is actively working on the
 > 3.0.0 release on the `main` branch. New features will only be addressed in 3.x moving forwards. If
-> need be, we will still fix bugs in 2.x.**
+> need be, we will still fix bugs in 2.x. A beta version, 3.0.0b2, is available for testing and we
+> would appreciate feedback.**
 
 ## The developers toolbox
 

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/README.md

@@ -27,7 +27,8 @@ when using cmd.
 
 > :warning: **cmd2 is now "feature complete" for the `2.x` branch and is actively working on the
 > 3.0.0 release on the `main` branch. New features will only be addressed in 3.x moving forwards. If
-> need be, we will still fix bugs in 2.x.**
+> need be, we will still fix bugs in 2.x. A beta version, 3.0.0b2, is available for testing and we
+> would appreciate feedback.**
 
 ## The developers toolbox
 

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/cmd2/plugin.py

@@ -1,4 +1,4 @@
-"""Classes for the cmd2 plugin system."""
+"""Classes for the cmd2 lifecycle hooks that you can register multiple callback functions/methods with."""
 
 from dataclasses import (
     dataclass,

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.0.0b2
+Version: 3.0.0rc1
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -58,7 +58,8 @@ when using cmd.
 
 > :warning: **cmd2 is now "feature complete" for the `2.x` branch and is actively working on the
 > 3.0.0 release on the `main` branch. New features will only be addressed in 3.x moving forwards. If
-> need be, we will still fix bugs in 2.x.**
+> need be, we will still fix bugs in 2.x. A beta version, 3.0.0b2, is available for testing and we
+> would appreciate feedback.**
 
 ## The developers toolbox
 

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/cmd2.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ codecov.yml
 mkdocs.yml
 package.json
 pyproject.toml
+ruff.toml
 tasks.py
 cmd2/__init__.py
 cmd2/argparse_completer.py
@@ -103,14 +104,14 @@ docs/migrating/index.md
 docs/migrating/minimum.md
 docs/migrating/next_steps.md
 docs/migrating/why.md
+docs/mixins/index.md
+docs/mixins/mixin_template.md
 docs/overrides/main.html
 docs/overview/alternatives.md
 docs/overview/index.md
 docs/overview/installation.md
 docs/overview/integrating.md
 docs/overview/resources.md
-docs/plugins/index.md
-docs/plugins/plugin_template.md
 docs/stylesheets/cmd2.css
 docs/stylesheets/readthedocs.css
 examples/.cmd2rc
@@ -124,6 +125,7 @@ examples/cmd_as_argument.py
 examples/color.py
 examples/command_sets.py
 examples/custom_parser.py
+examples/custom_types.py
 examples/default_categories.py
 examples/dynamic_commands.py
 examples/environment.py
@@ -134,6 +136,7 @@ examples/hello_cmd2.py
 examples/help_categories.py
 examples/hooks.py
 examples/migrating.py
+examples/mixin.py
 examples/modular_commands.py
 examples/paged_output.py
 examples/persistent_history.py
@@ -265,22 +268,6 @@ examples/transcripts/exampleSession.txt
 examples/transcripts/pirate.transcript
 examples/transcripts/quit.txt
 examples/transcripts/transcript_regex.txt
-plugins/README.txt
-plugins/tasks.py
-plugins/template/CHANGELOG.md
-plugins/template/LICENSE
-plugins/template/README.md
-plugins/template/build-pyenvs.sh
-plugins/template/noxfile.py
-plugins/template/setup.py
-plugins/template/tasks.py
-plugins/template/cmd2_myplugin/__init__.py
-plugins/template/cmd2_myplugin/myplugin.py
-plugins/template/cmd2_myplugin/pylintrc
-plugins/template/examples/example.py
-plugins/template/tests/__init__.py
-plugins/template/tests/pylintrc
-plugins/template/tests/test_myplugin.py
 tests/.cmd2rc
 tests/__init__.py
 tests/conftest.py

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/codecov.yml

@@ -5,10 +5,6 @@ component_management:
       name: cmd2 # this is a display name, and can be changed freely
       paths:
         - cmd2/**
-    - component_id: plugins
-      name: plugins
-      paths:
-        - plugins/**
 
 # Ignore certain paths, all files under these paths will be skipped during processing
 ignore:

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/docs/index.md

@@ -53,10 +53,10 @@ app.cmdloop()
     end="<!--intro-end-->"
 %}
 
-## Plugins
+## Mixins
 
 {%
-   include-markdown "./plugins/index.md"
+   include-markdown "./mixins/index.md"
     start="<!--intro-start-->"
     end="<!--intro-end-->"
 %}

cmd2-3.0.0rc1/docs/mixins/index.md

@@ -0,0 +1,7 @@
+# Mixins
+
+<!--intro-start-->
+
+- [cmd2 Mixin Template](mixin_template.md)
+
+<!--intro-end-->

cmd2-3.0.0rc1/docs/mixins/mixin_template.md

@@ -0,0 +1,170 @@
+# cmd2 Mixin Template
+
+## Mixin Classes in General
+
+In Python, a mixin is a class designed to provide a specific set of functionalities to other classes
+through multiple inheritance. Mixins are not intended to be instantiated on their own; rather, they
+serve as a way to "mix in" or compose behaviors into a base class without creating a rigid "is-a"
+relationship.
+
+For more information about Mixin Classes, we recommend this `Real Python` article on
+[What Are Mixin Classes in Python?](https://realpython.com/python-mixin/).
+
+## Overview of cmd2 mixins
+
+If you have some set of re-usable behaviors that you wish to apply to multiple different `cmd2`
+applications, then creating a mixin class to encapsulate this behavior can be a great idea. It is
+one way to extend `cmd2` by relying on multiple inheritance. It is quick and easy, but there are
+some potential pitfalls you should be aware of so you know how to do it correctly.
+
+The [mixins.py](https://github.com/python-cmd2/cmd2/blob/main/examples/mixins.py) example is a
+general example that shows you how you can develop a mixin class for `cmd2` applicaitons. In the
+past we have referred to these as "Plugins", but in retrospect that probably isn't the best name for
+them. They are generally mixin classes that add some extra functionality to your class which
+inherits from [cmd2.Cmd][].
+
+## Using this template
+
+This file provides a very basic template for how you can create your own cmd2 Mixin class to
+encapsulate re-usable behavior that can be applied to multiple `cmd2` applications via multiple
+inheritance.
+
+## Naming
+
+If you decide to publish your Mixin as a Python package, you should consider prefixing the name of
+your project with `cmd2-`. If you take this approach, then within that project, you should have a
+package with a prefix of `cmd2_`.
+
+## Adding functionality
+
+There are many ways to add functionality to `cmd2` using a mixin. A mixin is a class that
+encapsulates and injects code into another class. Developers who use a mixin in their `cmd2`
+project, will inject the mixin's code into their subclass of [cmd2.Cmd][].
+
+### Mixin and Initialization
+
+The following short example shows how to create a mixin class and how everything gets initialized.
+
+Here's the mixin:
+
+```python
+class MyMixin:
+    def __init__(self, *args, **kwargs):
+        # code placed here runs before cmd2.Cmd initializes
+        super().__init__(*args, **kwargs)
+        # code placed here runs after cmd2.Cmd initializes
+```
+
+and an example app which uses the mixin:
+
+```python
+import cmd2
+
+
+class Example(MyMixin, cmd2.Cmd):
+    """A cmd2 application class to show how to use a mixin class."""
+
+    def __init__(self, *args, **kwargs):
+        # code placed here runs before cmd2.Cmd or
+        # any mixins initialize
+        super().__init__(*args, **kwargs)
+        # code placed here runs after cmd2.Cmd and
+        # all mixins have initialized
+```
+
+Note how the mixin must be inherited (or mixed in) before `cmd2.Cmd`. This is required for two
+reasons:
+
+- The `cmd.Cmd.__init__()` method in the python standard library does not call `super().__init__()`.
+  Because of this oversight, if you don't inherit from `MyMixin` first, the `MyMixin.__init__()`
+  method will never be called.
+- You may want your mixin to be able to override methods from `cmd2.Cmd`. If you mixin the mixin
+  class after `cmd2.Cmd`, the python method resolution order will call `cmd2.Cmd` methods before it
+  calls those in your mixin.
+
+### Add commands
+
+Your mixin can add user visible commands. You do it the same way in a mixin that you would in a
+`cmd2.Cmd` app:
+
+```python
+class MyMixin:
+
+    def do_say(self, statement):
+        """Simple say command"""
+        self.poutput(statement)
+```
+
+You have all the same capabilities within the mixin that you do inside a `cmd2.Cmd` app, including
+argument parsing via decorators and custom help methods.
+
+### Add (or hide) settings
+
+A mixin may add user controllable settings to the application. Here's an example:
+
+```python
+class MyMixin:
+    def __init__(self, *args, **kwargs):
+        # code placed here runs before cmd2.Cmd initializes
+        super().__init__(*args, **kwargs)
+        # code placed here runs after cmd2.Cmd initializes
+        self.mysetting = 'somevalue'
+        self.settable.update({'mysetting': 'short help message for mysetting'})
+```
+
+You can also hide settings from the user by removing them from `self.settable`.
+
+### Decorators
+
+Your mixin can provide a decorator which users of your mixin can use to wrap functionality around
+their own commands.
+
+### Override methods
+
+Your mixin can override core `cmd2.Cmd` methods, changing their behavior. This approach should be
+used sparingly, because it is very brittle. If a developer chooses to use multiple mixins in their
+application, and several of the mixins override the same method, only the first mixin to be mixed in
+will have the overridden method called.
+
+Hooks are a much better approach.
+
+### Hooks
+
+Mixins can register hooks, which are called by `cmd2.Cmd` during various points in the application
+and command processing lifecycle. Mixins should not override any of the legacy `cmd` hook methods,
+instead they should register their hooks as
+[described](https://cmd2.readthedocs.io/en/latest/hooks.html) in the `cmd2` documentation.
+
+You should name your hooks so that they begin with the name of your mixin. Hook methods get mixed
+into the `cmd2` application and this naming convention helps avoid unintentional method overriding.
+
+Here's a simple example:
+
+```python
+class MyMixin:
+
+    def __init__(self, *args, **kwargs):
+        # code placed here runs before cmd2 initializes
+        super().__init__(*args, **kwargs)
+        # code placed here runs after cmd2 initializes
+        # this is where you register any hook functions
+        self.register_postparsing_hook(self.cmd2_mymixin_postparsing_hook)
+
+    def cmd2_mymixin_postparsing_hook(self, data: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
+        """Method to be called after parsing user input, but before running the command"""
+        self.poutput('in postparsing_hook')
+        return data
+```
+
+Registration allows multiple mixins (or even the application itself) to each inject code to be
+called during the application or command processing lifecycle.
+
+See the [cmd2 hook documentation](https://cmd2.readthedocs.io/en/latest/hooks.html) for full details
+of the application and command lifecycle, including all available hooks and the ways hooks can
+influence the lifecycle.
+
+### Classes and Functions
+
+Your mixin can also provide classes and functions which can be used by developers of `cmd2` based
+applications. Describe these classes and functions in your documentation so users of your mixin will
+know what's available.

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/docs/upgrades.md

@@ -20,6 +20,18 @@ The functionality within the `cmd2.ansi` module has either been removed or chang
 `rich` and moved to one of the new modules: [cmd2.string_utils][], [cmd2.styles][], or
 [cmd2.terminal_utils][].
 
+To ease the migration path from `cmd2` 2.x to 3.x, we have created the `cmd2-ansi` module which is a
+backport of the `cmd2.ansi` module present in `cmd2` 2.7.0 in a standalone fashion. Relevant links:
+
+- PyPI: [cmd2-ansi](https://pypi.org/project/cmd2-ansi/)
+- GitHub: [cmd2-ansi](https://github.com/python-cmd2/cmd2-ansi)
+
+To use this backport:
+
+```Python
+from cmd2_ansi import ansi
+```
+
 #### table_creator
 
 The `cmd2.table_creator` module no longer exists. Please see rich's documentation on
@@ -31,6 +43,19 @@ demonstrates how to use `rich` tables in a `cmd2` application.
 offered. We apologize for this backwards incompatibility, but the APIs were fundamentally different
 and we could not figure out a way to create a backwards-compatibility wrapper.
 
+To ease the migration path from `cmd2` 2.x to 3.x, we have created the `cmd2-table` module which is
+a backport of the `cmd2.table_creator` module present in `cmd2` 2.7.0 in a standalone fashion.
+Relevant links:
+
+- PyPI: [cmd2-table](https://pypi.org/project/cmd2-table/)
+- GitHub: [cmd2-table](https://github.com/python-cmd2/cmd2-table)
+
+To use this backport:
+
+```Python
+from cmd2_table import table_creator
+```
+
 ### Added modules
 
 #### colors

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/examples/README.md

@@ -32,6 +32,8 @@ each:
       subcommands, etc.
 - [custom_parser.py](https://github.com/python-cmd2/cmd2/blob/main/examples/custom_parser.py)
     - Demonstrates how to create your own custom `Cmd2ArgumentParser`
+- [custom_types.py](https://github.com/python-cmd2/cmd2/blob/main/examples/custom_types.py)
+    - Some useful custom argument types
 - [default_categories.py](https://github.com/python-cmd2/cmd2/blob/main/examples/default_categories.py)
     - Demonstrates usage of `@with_default_category` decorator to group and categorize commands and
       `CommandSet` use

cmd2-3.0.0rc1/examples/custom_types.py

@@ -0,0 +1,165 @@
+"""Some useful argument types.
+
+Note that these types can be used with other argparse-compatible libraries, including
+"argparse" itself.
+
+The 'type' parameter to ArgumentParser.add_argument() must be a callable object,
+typically a function. That function is called to convert the string to the Python type available
+in the 'namespace' passed to your "do_xyz" command function. Thus, "type=int" works because
+int("53") returns the integer value 53. If that callable object / function raises an exception
+due to invalid input, the name ("repr") of the object/function will be printed in the error message
+to the user. Using lambda, functools.partial, or the like will generate a callable object with a
+rather opaque repr so it can be useful to have a one-line function rather than relying on a lambda,
+even for a short expression.
+
+For "types" that have some context/state, using a class with a __call__ method, and overriding
+the __repr__ method, allows you to produce an error message that provides that information
+to the user.
+"""
+
+from collections.abc import Iterable
+
+import cmd2
+
+_int_suffixes = {
+    # SI number suffixes (unit prefixes):
+    "K": 1_000,
+    "M": 1_000_000,
+    "G": 1_000_000_000,
+    "T": 1_000_000_000_000,
+    "P": 1_000_000_000_000_000,
+    # IEC number suffixes (unit prefixes):
+    "Ki": 1024,
+    "Mi": 1024 * 1024,
+    "Gi": 1024 * 1024 * 1024,
+    "Ti": 1024 * 1024 * 1024 * 1024,
+    "Pi": 1024 * 1024 * 1024 * 1024 * 1024,
+}
+
+
+def integer(value_str: str) -> int:
+    """Will accept any base, and optional suffix like '64K'."""
+    multiplier = 1
+    # If there is a matching suffix, use its multiplier:
+    for suffix, suffix_multiplier in _int_suffixes.items():
+        if value_str.endswith(suffix):
+            value_str = value_str.removesuffix(suffix)
+            multiplier = suffix_multiplier
+            break
+
+    return int(value_str, 0) * multiplier
+
+
+def hexadecimal(value_str: str) -> int:
+    """Parse hexidecimal integer, with optional '0x' prefix."""
+    return int(value_str, base=16)
+
+
+class Range:
+    """Useful as type for large ranges, when 'choices=range(maxval)' would be excessively large."""
+
+    def __init__(self, firstval: int, secondval: int | None = None) -> None:
+        """Construct a Range, with same syntax as 'range'.
+
+        :param firstval: either the top end of range (if 'secondval' is missing), or the bottom end
+        :param secondval: top end of range (one higher than maximum value)
+        """
+        if secondval is None:
+            self.bottom = 0
+            self.top = firstval
+        else:
+            self.bottom = firstval
+            self.top = secondval
+
+        self.range_str = f"[{self.bottom}..{self.top - 1}]"
+
+    def __repr__(self) -> str:
+        """Will be printed as the 'argument type' to user on syntax or range error."""
+        return f"Range{self.range_str}"
+
+    def __call__(self, arg: str) -> int:
+        """Parse the string argument and checks validity."""
+        val = integer(arg)
+        if self.bottom <= val < self.top:
+            return val
+        raise ValueError(f"Value '{val}' not within {self.range_str}")
+
+
+class IntSet:
+    """Set of integers from a specified range.
+
+    e.g. '5', '1-3,8', 'all'
+    """
+
+    def __init__(self, firstval: int, secondval: int | None = None) -> None:
+        """Construct an IntSet, with same syntax as 'range'.
+
+        :param firstval: either the top end of range (if 'secondval' is missing), or the bottom end
+        :param secondval: top end of range (one higher than maximum value)
+        """
+        if secondval is None:
+            self.bottom = 0
+            self.top = firstval
+        else:
+            self.bottom = firstval
+            self.top = secondval
+
+        self.range_str = f"[{self.bottom}..{self.top - 1}]"
+
+    def __repr__(self) -> str:
+        """Will be printed as the 'argument type' to user on syntax or range error."""
+        return f"IntSet{self.range_str}"
+
+    def __call__(self, arg: str) -> Iterable[int]:
+        """Parse a string into an iterable returning ints."""
+        if arg == 'all':
+            return range(self.bottom, self.top)
+
+        out = []
+        for piece in arg.split(','):
+            if '-' in piece:
+                a, b = [int(x) for x in piece.split('-', 2)]
+                if a < self.bottom:
+                    raise ValueError(f"Value '{a}' not within {self.range_str}")
+                if b >= self.top:
+                    raise ValueError(f"Value '{b}' not within {self.range_str}")
+                out += list(range(a, b + 1))
+            else:
+                val = int(piece)
+                if not self.bottom <= val < self.top:
+                    raise ValueError(f"Value '{val}' not within {self.range_str}")
+                out += [val]
+        return out
+
+
+if __name__ == '__main__':
+    import argparse
+    import sys
+
+    class CustomTypesExample(cmd2.Cmd):
+        example_parser = cmd2.Cmd2ArgumentParser()
+        example_parser.add_argument(
+            '--value', '-v', type=integer, help='Integer value, with optional K/M/G/Ki/Mi/Gi/... suffix'
+        )
+        example_parser.add_argument('--memory-address', '-m', type=hexadecimal, help='Memory address in hex')
+        example_parser.add_argument('--year', type=Range(1900, 2000), help='Year between 1900-1999')
+        example_parser.add_argument(
+            '--index', dest='index_list', type=IntSet(100), help='One or more indexes 0-99. e.g. "1,3,5", "10,30-50", "all"'
+        )
+
+        @cmd2.with_argparser(example_parser)
+        def do_example(self, args: argparse.Namespace) -> None:
+            """The example command."""
+            if args.value is not None:
+                self.poutput(f"Value: {args.value}")
+            if args.memory_address is not None:
+                # print the value as hex, with leading "0x" + 16 hex digits + three '_' group separators:
+                self.poutput(f"Address: {args.memory_address:#021_x}")
+            if args.year is not None:
+                self.poutput(f"Year: {args.year}")
+            if args.index_list is not None:
+                for index in args.index_list:
+                    self.poutput(f"Process index {index}")
+
+    app = CustomTypesExample()
+    sys.exit(app.cmdloop())

cmd2-3.0.0b2/plugins/template/cmd2_myplugin/myplugin.py → cmd2-3.0.0rc1/examples/mixin.py

@@ -1,4 +1,5 @@
-"""An example cmd2 plugin."""
+#!/usr/bin/env python
+"""An example cmd2 mixin."""
 
 import functools
 from collections.abc import Callable
@@ -13,7 +14,7 @@ else:
 
 
 def empty_decorator(func: Callable) -> Callable:
-    """An empty decorator for myplugin."""
+    """An empty decorator for use with your mixin."""
 
     @functools.wraps(func)
     def _empty_decorator(self, *args, **kwargs) -> None:
@@ -24,15 +25,15 @@ def empty_decorator(func: Callable) -> Callable:
     return _empty_decorator
 
 
-class MyPluginMixin(_Base):
+class MyMixin(_Base):
     """A mixin class which adds a 'say' command to a cmd2 subclass.
 
     The order in which you add the mixin matters. Say you want to
     use this mixin in a class called MyApp.
 
-    class MyApp(cmd2_myplugin.MyPlugin, cmd2.Cmd):
+    class MyApp(MyMixin, cmd2.Cmd):
         def __init__(self, *args, **kwargs):
-            # gotta have this or neither the plugin or cmd2 will initialize
+            # gotta have this or neither the mixin or cmd2 will initialize
             super().__init__(*args, **kwargs)
     """
 
@@ -41,9 +42,9 @@ class MyPluginMixin(_Base):
         super().__init__(*args, **kwargs)
         # code placed here runs after cmd2 initializes
         # this is where you register any hook functions
-        self.register_preloop_hook(self.cmd2_myplugin_preloop_hook)
-        self.register_postloop_hook(self.cmd2_myplugin_postloop_hook)
-        self.register_postparsing_hook(self.cmd2_myplugin_postparsing_hook)
+        self.register_preloop_hook(self.cmd2_mymixin_preloop_hook)
+        self.register_postloop_hook(self.cmd2_mymixin_postloop_hook)
+        self.register_postparsing_hook(self.cmd2_mymixin_postparsing_hook)
 
     def do_say(self, statement) -> None:
         """Simple say command."""
@@ -51,15 +52,32 @@ class MyPluginMixin(_Base):
 
     #
     # define hooks as functions, not methods
-    def cmd2_myplugin_preloop_hook(self) -> None:
+    def cmd2_mymixin_preloop_hook(self) -> None:
         """Method to be called before the command loop begins."""
         self.poutput("preloop hook")
 
-    def cmd2_myplugin_postloop_hook(self) -> None:
+    def cmd2_mymixin_postloop_hook(self) -> None:
         """Method to be called after the command loop finishes."""
         self.poutput("postloop hook")
 
-    def cmd2_myplugin_postparsing_hook(self, data: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
+    def cmd2_mymixin_postparsing_hook(self, data: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
         """Method to be called after parsing user input, but before running the command."""
         self.poutput('in postparsing hook')
         return data
+
+
+class Example(MyMixin, cmd2.Cmd):
+    """An class to show how to use a mixin."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        # gotta have this or neither the mixin or cmd2 will initialize
+        super().__init__(*args, **kwargs)
+
+    @empty_decorator
+    def do_something(self, _arg) -> None:
+        self.poutput('this is the something command')
+
+
+if __name__ == '__main__':
+    app = Example()
+    app.cmdloop()

{cmd2-3.0.0b2 → cmd2-3.0.0rc1}/mkdocs.yml

@@ -193,9 +193,9 @@ nav:
       - examples/getting_started.md
       - examples/alternate_event_loops.md
       - examples/examples.md
-  - Plugins:
-      - plugins/index.md
-      - plugins/plugin_template.md
+  - Mixins:
+      - mixins/index.md
+      - mixins/mixin_template.md
   - Testing:
       - testing.md
   - API Reference: