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

cmd2/rl_utils.py

@@ -2,6 +2,7 @@
 """
 Imports the proper Readline for the platform and provides utility functions for it
 """
+
 import sys
 from enum import (
     Enum,
@@ -28,19 +29,17 @@ from typing import (
 
 # Prefer statically linked gnureadline if installed due to compatibility issues with libedit
 try:
-    # noinspection PyPackageRequirements
     import gnureadline as readline  # type: ignore[import]
 except ImportError:
     # Note: If this actually fails, you should install gnureadline on Linux/Mac or pyreadline3 on Windows.
     try:
-        # noinspection PyUnresolvedReferences
         import readline  # type: ignore[no-redef]
     except ImportError:  # pragma: no cover
         pass
 
 
 class RlType(Enum):
-    """Readline library types we recognize"""
+    """Readline library types we support"""
 
     GNU = 1
     PYREADLINE = 2
@@ -70,8 +69,8 @@ if 'pyreadline3' in sys.modules:
     )
 
     # Check if we are running in a terminal
-    if sys.stdout.isatty():  # pragma: no cover
-        # noinspection PyPep8Naming,PyUnresolvedReferences
+    if sys.stdout is not None and sys.stdout.isatty():  # pragma: no cover
+
         def enable_win_vt100(handle: HANDLE) -> bool:
             """
             Enables VT100 character sequences in a Windows console
@@ -101,27 +100,18 @@ if 'pyreadline3' in sys.modules:
         # Enable VT100 sequences for stdout and stderr
         STD_OUT_HANDLE = -11
         STD_ERROR_HANDLE = -12
-        # noinspection PyUnresolvedReferences
         vt100_stdout_support = enable_win_vt100(readline.rl.console.GetStdHandle(STD_OUT_HANDLE))
-        # noinspection PyUnresolvedReferences
         vt100_stderr_support = enable_win_vt100(readline.rl.console.GetStdHandle(STD_ERROR_HANDLE))
         vt100_support = vt100_stdout_support and vt100_stderr_support
 
     ############################################################################################################
     # pyreadline3 is incomplete in terms of the Python readline API. Add the missing functions we need.
     ############################################################################################################
-    # readline.redisplay()
-    try:
-        getattr(readline, 'redisplay')
-    except AttributeError:
-        # noinspection PyProtectedMember,PyUnresolvedReferences
-        readline.redisplay = readline.rl.mode._update_line
-
     # readline.remove_history_item()
     try:
         getattr(readline, 'remove_history_item')
     except AttributeError:
-        # noinspection PyProtectedMember,PyUnresolvedReferences
+
         def pyreadline_remove_history_item(pos: int) -> None:
             """
             An implementation of remove_history_item() for pyreadline3
@@ -141,7 +131,7 @@ if 'pyreadline3' in sys.modules:
 
 elif 'gnureadline' in sys.modules or 'readline' in sys.modules:
     # We don't support libedit. See top of this file for why.
-    if 'libedit' not in readline.__doc__:
+    if readline.__doc__ is not None and 'libedit' not in readline.__doc__:
         try:
             # Load the readline lib so we can access members of it
             import ctypes
@@ -156,7 +146,7 @@ elif 'gnureadline' in sys.modules or 'readline' in sys.modules:
             rl_type = RlType.GNU
             vt100_support = sys.stdout.isatty()
 
-# Check if readline was loaded
+# Check if we loaded a supported version of readline
 if rl_type == RlType.NONE:  # pragma: no cover
     if not _rl_warn_reason:
         _rl_warn_reason = (
@@ -168,7 +158,6 @@ else:
     rl_warning = ''
 
 
-# noinspection PyProtectedMember,PyUnresolvedReferences
 def rl_force_redisplay() -> None:  # pragma: no cover
     """
     Causes readline to display the prompt and input text wherever the cursor is and start
@@ -191,7 +180,6 @@ def rl_force_redisplay() -> None:  # pragma: no cover
         readline.rl.mode._update_line()
 
 
-# noinspection PyProtectedMember, PyUnresolvedReferences
 def rl_get_point() -> int:  # pragma: no cover
     """
     Returns the offset of the current cursor position in rl_line_buffer
@@ -206,9 +194,8 @@ def rl_get_point() -> int:  # pragma: no cover
         return 0
 
 
-# noinspection PyUnresolvedReferences
 def rl_get_prompt() -> str:  # pragma: no cover
-    """Gets Readline's current prompt"""
+    """Get Readline's prompt"""
     if rl_type == RlType.GNU:
         encoded_prompt = ctypes.c_char_p.in_dll(readline_lib, "rl_prompt").value
         if encoded_prompt is None:
@@ -229,7 +216,24 @@ def rl_get_prompt() -> str:  # pragma: no cover
     return rl_unescape_prompt(prompt)
 
 
-# noinspection PyUnresolvedReferences
+def rl_get_display_prompt() -> str:  # pragma: no cover
+    """
+    Get Readline's currently displayed prompt.
+
+    In GNU Readline, the displayed prompt sometimes differs from the prompt.
+    This occurs in functions that use the prompt string as a message area, such as incremental search.
+    """
+    if rl_type == RlType.GNU:
+        encoded_prompt = ctypes.c_char_p.in_dll(readline_lib, "rl_display_prompt").value
+        if encoded_prompt is None:
+            prompt = ''
+        else:
+            prompt = encoded_prompt.decode(encoding='utf-8')
+        return rl_unescape_prompt(prompt)
+    else:
+        return rl_get_prompt()
+
+
 def rl_set_prompt(prompt: str) -> None:  # pragma: no cover
     """
     Sets Readline's prompt
@@ -246,7 +250,8 @@ def rl_set_prompt(prompt: str) -> None:  # pragma: no cover
 
 
 def rl_escape_prompt(prompt: str) -> str:
-    """Overcome bug in GNU Readline in relation to calculation of prompt length in presence of ANSI escape codes
+    """
+    Overcome bug in GNU Readline in relation to calculation of prompt length in presence of ANSI escape codes
 
     :param prompt: original prompt
     :return: prompt safe to pass to GNU Readline
@@ -285,3 +290,32 @@ def rl_unescape_prompt(prompt: str) -> str:
         prompt = prompt.replace(escape_start, "").replace(escape_end, "")
 
     return prompt
+
+
+def rl_in_search_mode() -> bool:  # pragma: no cover
+    """Check if readline is doing either an incremental (e.g. Ctrl-r) or non-incremental (e.g. Esc-p) search"""
+    if rl_type == RlType.GNU:
+        # GNU Readline defines constants that we can use to determine if in search mode.
+        #     RL_STATE_ISEARCH    0x0000080
+        #     RL_STATE_NSEARCH    0x0000100
+        IN_SEARCH_MODE = 0x0000180
+
+        readline_state = ctypes.c_int.in_dll(readline_lib, "rl_readline_state").value
+        return bool(IN_SEARCH_MODE & readline_state)
+    elif rl_type == RlType.PYREADLINE:
+        from pyreadline3.modes.emacs import (  # type: ignore[import]
+            EmacsMode,
+        )
+
+        # These search modes only apply to Emacs mode, which is the default.
+        if not isinstance(readline.rl.mode, EmacsMode):
+            return False
+
+        # While in search mode, the current keyevent function is set one of the following.
+        search_funcs = (
+            readline.rl.mode._process_incremental_search_keyevent,
+            readline.rl.mode._process_non_incremental_search_keyevent,
+        )
+        return readline.rl.mode.process_keyevent_queue[-1] in search_funcs
+    else:
+        return False

cmd2/table_creator.py

@@ -5,6 +5,7 @@ This API is built upon two core classes: Column and TableCreator
 The general use case is to inherit from TableCreator to create a table class with custom formatting options.
 There are already implemented and ready-to-use examples of this below TableCreator's code.
 """
+
 import copy
 import io
 from collections import (

cmd2/transcript.py

@@ -9,6 +9,7 @@ a unit test, comparing the expected output to the actual output.
 This file contains the class necessary to make that work. This
 class is used in cmd2.py::run_transcript_tests()
 """
+
 import re
 import unittest
 from typing import (
@@ -60,7 +61,7 @@ class Cmd2TestCase(unittest.TestCase):
     def runTest(self) -> None:  # was testall
         if self.cmdapp:
             its = sorted(self.transcripts.items())
-            for (fname, transcript) in its:
+            for fname, transcript in its:
                 self._test_transcript(fname, transcript)
 
     def _fetchTranscripts(self) -> None:
@@ -204,7 +205,7 @@ class Cmd2TestCase(unittest.TestCase):
                 # escaped. We found it.
                 break
             else:
-                # check if the slash is preceeded by a backslash
+                # check if the slash is preceded by a backslash
                 if s[pos - 1 : pos] == '\\':
                     # it is.
                     if in_regex:

cmd2/utils.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 """Shared utility functions"""
+
 import argparse
 import collections
 import functools
@@ -12,6 +13,9 @@ import subprocess
 import sys
 import threading
 import unicodedata
+from difflib import (
+    SequenceMatcher,
+)
 from enum import (
     Enum,
 )
@@ -154,7 +158,7 @@ class Settable:
         :param choices_provider: function that provides choices for this argument
         :param completer: tab completion function that provides choices for this argument
         """
-        if val_type == bool:
+        if val_type is bool:
 
             def get_bool_choices(_) -> List[str]:  # type: ignore[no-untyped-def]
                 """Used to tab complete lowercase boolean values"""
@@ -174,17 +178,14 @@ class Settable:
         self.completer = completer
 
     def get_value(self) -> Any:
-        """
-        Get the value of the settable attribute
-        :return:
-        """
+        """Get the value of the settable attribute."""
         return getattr(self.settable_obj, self.settable_attrib_name)
 
-    def set_value(self, value: Any) -> Any:
+    def set_value(self, value: Any) -> None:
         """
-        Set the settable attribute on the specified destination object
-        :param value: New value to set
-        :return: New value that the attribute was set to
+        Set the settable attribute on the specified destination object.
+
+        :param value: new value to set
         """
         # Run the value through its type function to handle any conversion or validation
         new_value = self.val_type(value)
@@ -201,7 +202,6 @@ class Settable:
         # Check if we need to call an onchange callback
         if orig_value != new_value and self.onchange_cb:
             self.onchange_cb(self.name, orig_value, new_value)
-        return new_value
 
 
 def is_text_file(file_path: str) -> bool:
@@ -668,7 +668,6 @@ class ProcReader:
 
         # Run until process completes
         while self._proc.poll() is None:
-            # noinspection PyUnresolvedReferences
             available = read_stream.peek()  # type: ignore[attr-defined]
             if available:
                 read_stream.read(len(available))
@@ -871,7 +870,8 @@ def align_text(
     )
 
     if width is None:
-        width = shutil.get_terminal_size().columns
+        # Prior to Python 3.11 this can return 0, so use a fallback if needed.
+        width = shutil.get_terminal_size().columns or constants.DEFAULT_TERMINAL_WIDTH
 
     if width < 1:
         raise ValueError("width must be at least 1")
@@ -1152,17 +1152,18 @@ def categorize(func: Union[Callable[..., Any], Iterable[Callable[..., Any]]], ca
     :param func: function or list of functions to categorize
     :param category: category to put it in
 
-    :Example:
+    Example:
+
+    ```py
+    import cmd2
+    class MyApp(cmd2.Cmd):
+      def do_echo(self, arglist):
+        self.poutput(' '.join(arglist)
 
-    >>> import cmd2
-    >>> class MyApp(cmd2.Cmd):
-    >>>   def do_echo(self, arglist):
-    >>>     self.poutput(' '.join(arglist)
-    >>>
-    >>>   cmd2.utils.categorize(do_echo, "Text Processing")
+      cmd2.utils.categorize(do_echo, "Text Processing")
+    ```
 
-    For an alternative approach to categorizing commands using a decorator, see
-    :func:`~cmd2.decorators.with_category`
+    For an alternative approach to categorizing commands using a decorator, see [cmd2.decorators.with_category][]
     """
     if isinstance(func, Iterable):
         for item in func:
@@ -1187,9 +1188,7 @@ def get_defining_class(meth: Callable[..., Any]) -> Optional[Type[Any]]:
     if isinstance(meth, functools.partial):
         return get_defining_class(meth.func)
     if inspect.ismethod(meth) or (
-        inspect.isbuiltin(meth)
-        and getattr(meth, '__self__') is not None
-        and getattr(meth.__self__, '__class__')  # type: ignore[attr-defined]
+        inspect.isbuiltin(meth) and getattr(meth, '__self__') is not None and getattr(meth.__self__, '__class__')
     ):
         for cls in inspect.getmro(meth.__self__.__class__):  # type: ignore[attr-defined]
             if meth.__name__ in cls.__dict__:
@@ -1262,3 +1261,36 @@ def strip_doc_annotations(doc: str) -> str:
         elif found_first:
             break
     return cmd_desc
+
+
+def similarity_function(s1: str, s2: str) -> float:
+    # The ratio from s1,s2 may be different to s2,s1. We keep the max.
+    # See https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.ratio
+    return max(SequenceMatcher(None, s1, s2).ratio(), SequenceMatcher(None, s2, s1).ratio())
+
+
+MIN_SIMIL_TO_CONSIDER = 0.7
+
+
+def suggest_similar(
+    requested_command: str, options: Iterable[str], similarity_function_to_use: Optional[Callable[[str, str], float]] = None
+) -> Optional[str]:
+    """
+    Given a requested command and an iterable of possible options returns the most similar (if any is similar)
+
+    :param requested_command: The command entered by the user
+    :param options: The list of available commands to search for the most similar
+    :param similarity_function_to_use: An optional callable to use to compare commands
+    :return: The most similar command or None if no one is similar
+    """
+
+    proposed_command = None
+    best_simil = MIN_SIMIL_TO_CONSIDER
+    requested_command_to_compare = requested_command.lower()
+    similarity_function_to_use = similarity_function_to_use or similarity_function
+    for each in options:
+        simil = similarity_function_to_use(each.lower(), requested_command_to_compare)
+        if best_simil < simil:
+            best_simil = simil
+            proposed_command = each
+    return proposed_command

{cmd2-2.4.3.dist-info → cmd2-2.5.9.dist-info}/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.5.9.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.2
+Name: cmd2
+Version: 2.5.9
+Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
+Author: cmd2 Contributors
+License: The MIT License (MIT)
+        
+        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
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+        
+Keywords: CLI,cmd,command,interactive,prompt,Python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gnureadline>=8; platform_system == "Darwin"
+Requires-Dist: pyperclip>=1.8
+Requires-Dist: pyreadline3>=3.4; platform_system == "Windows"
+Requires-Dist: wcwidth>=0.2.10
+
+<h1 align="center">cmd2 : immersive interactive command line applications</h1>
+
+[![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
+[![GitHub Actions](https://github.com/python-cmd2/cmd2/workflows/CI/badge.svg)](https://github.com/python-cmd2/cmd2/actions?query=workflow%3ACI)
+[![codecov](https://codecov.io/gh/python-cmd2/cmd2/branch/master/graph/badge.svg)](https://codecov.io/gh/python-cmd2/cmd2)
+[![Documentation Status](https://readthedocs.org/projects/cmd2/badge/?version=latest)](http://cmd2.readthedocs.io/en/latest/?badge=latest)
+<a href="https://discord.gg/RpVG6tk"><img src="https://img.shields.io/badge/chat-on%20discord-7289da.svg" alt="Chat"></a>
+
+<p align="center">
+  <a href="#the-developers-toolbox">Developer's Toolbox</a> •
+  <a href="#philosophy">Philosophy</a> •
+  <a href="#installation">Installation</a> •
+  <a href="#documentation">Documentation</a> •
+  <a href="#tutorials">Tutorials</a> •
+  <a href="#hello-world">Hello World</a> •
+  <a href="#projects-using-cmd2">Projects using cmd2</a> •
+</p>
+
+[![Screenshot](https://raw.githubusercontent.com/python-cmd2/cmd2/master/cmd2.png)](https://youtu.be/DDU_JH6cFsA)
+
+cmd2 is a tool for building interactive command line applications in Python. Its goal is to make it
+quick and easy for developers to build feature-rich and user-friendly interactive command line
+applications. It provides a simple API which is an extension of Python's built-in
+[cmd](https://docs.python.org/3/library/cmd.html) module. cmd2 provides a wealth of features on top
+of cmd to make your life easier and eliminates much of the boilerplate code which would be necessary
+when using cmd.
+
+## 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.
+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.
+
+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
+- Automation Transition
+
+## Philosophy
+
+<a href="https://imgflip.com/i/63h03x"><img src="https://i.imgflip.com/63h03x.jpg" title="made at imgflip.com" width="70%" height="%70"/></a>
+
+Deep extensive tab completion and help text generation based on the argparse library create the first pillar of 'ease of command discovery'. The following is a list of features in this category.
+
+- Great tab completion of commands, subcommands, file system paths, and shell commands.
+- Custom tab completion for user designed commands via simple function overloading.
+- Tab completion from `persistent_history_file` sources added with very little friction.
+- Automatic tab completion of `argparse` flags and optional arguments.
+- Path completion easily enabled.
+- When all else fails, custom tab completion based on `choices_provider` can fill any gaps.
+
+<a href="https://imgflip.com/i/66t0y0"><img src="https://i.imgflip.com/66t0y0.jpg" title="made at imgflip.com" width="70%" height="70%"/></a>
+
+cmd2 creates the second pillar of 'ease of transition to automation' through alias/macro creation, command line argument parsing and execution of cmd2 scripting.
+
+- Flexible alias and macro creation for quick abstraction of commands.
+- Text file scripting of your application with `run_script` (`@`) and `_relative_run_script` (`@@`)
+- Powerful and flexible built-in Python scripting of your application using the `run_pyscript` command
+- Transcripts for use with built-in regression can be automatically generated from `history -t` or `run_script -t`
+
+## Installation
+
+On all operating systems, the latest stable version of `cmd2` can be installed using pip:
+
+```bash
+pip install -U cmd2
+```
+
+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
+documentation.
+
+## Documentation
+
+The latest documentation for cmd2 can be read online here: https://cmd2.readthedocs.io/en/latest/
+
+It is available in HTML, PDF, and ePub formats.
+
+The best way to learn the cmd2 api is to delve into the example applications located in source under examples.
+
+## Tutorials
+
+- 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)
+- [Cookiecutter](https://github.com/cookiecutter/cookiecutter) Templates from community
+    - Basic cookiecutter template for cmd2 application : https://github.com/jayrod/cookiecutter-python-cmd2
+    - Advanced cookiecutter template with external plugin support : https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
+- [cmd2 example applications](https://github.com/python-cmd2/cmd2/tree/master/examples)
+    - Basic cmd2 examples to demonstrate how to use various features
+- [Advanced Examples](https://github.com/jayrod/cmd2-example-apps)
+    - More complex examples that demonstrate more featuers about how to put together a complete application
+
+## Hello World
+
+```python
+#!/usr/bin/env python
+"""A simple cmd2 application."""
+import cmd2
+
+
+class FirstApp(cmd2.Cmd):
+    """A simple cmd2 application."""
+
+  def do_hello_world(self, _: cmd2.Statement):
+    self.poutput('Hello World')
+
+if __name__ == '__main__':
+    import sys
+    c = FirstApp()
+    sys.exit(c.cmdloop())
+
+```
+
+## Found a bug?
+
+If you think you've found a bug, please first read through the open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new GitHub issue. Be sure to include as much information as possible so we can reproduce the bug. At a minimum, please state the following:
+
+- `cmd2` version
+- Python version
+- OS name and version
+- What you did to cause the bug to occur
+- Include any traceback or error message associated with the bug
+
+## Projects using cmd2
+
+| Application Name                                                | Description                                                                                                                     | Organization or Author                                                |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| [CephFS Shell](https://github.com/ceph/ceph)                    | The Ceph File System, or CephFS, is a POSIX-compliant file system built on top of Ceph’s distributed object store               | [ceph](https://ceph.com/)                                             |
+| [garak](https://github.com/NVIDIA/garak)                        | LLM vulnerability scanner that checks if an LLM can be made to fail in a way we don't want                                      | [NVIDIA](https://github.com/NVIDIA)                                   |
+| [medusa](https://github.com/Ch0pin/medusa)                      | Binary instrumentation framework that that automates processes for the dynamic analysis of Android and iOS Applications         | [Ch0pin](https://github.com/Ch0pin)                                   |
+| [InternalBlue](https://github.com/seemoo-lab/internalblue)      | Bluetooth experimentation framework for Broadcom and Cypress chips                                                              | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
+| [SCCMHunter](https://github.com/garrettfoster13/sccmhunter)     | A post-ex tool built to streamline identifying, profiling, and attacking SCCM related assets in an Active Directory domain      | [Garret Foster](https://github.com/garrettfoster13)                   |
+| [Unipacker](https://github.com/unipacker/unipacker)             | Automatic and platform-independent unpacker for Windows binaries based on emulation                                             | [unipacker](https://github.com/unipacker)                             |
+| [Frankenstein](https://github.com/seemoo-lab/frankenstein)      | Broadcom and Cypress firmware emulation for fuzzing and further full-stack debugging                                            | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
+| [Poseidon](https://github.com/faucetsdn/poseidon)               | Leverages software-defined networks (SDNs) to acquire and then feed network traffic to a number of machine learning techniques. | [Faucet SDN](https://github.com/faucetsdn)                            |
+| [DFTimewolf](https://github.com/log2timeline/dftimewolf)        | A framework for orchestrating forensic collection, processing and data export                                                   | [log2timeline](https://github.com/log2timeline)                       |
+| [GAP SDK](https://github.com/GreenWaves-Technologies/gap_sdk)   | SDK for Greenwaves Technologies' GAP8 IoT Application Processor                                                                 | [GreenWaves Technologies](https://github.com/GreenWaves-Technologies) |
+| [REW Sploit](https://github.com/REW-sploit/REW-sploit)          | Emulate and Dissect Metasploit Framework (MSF) and other attacks                                                                | [REW-sploit](https://github.com/REW-sploit)                           |
+| [tomcatmanager](https://github.com/tomcatmanager/tomcatmanager) | A command line tool and python library for managing a tomcat server                                                             | [tomcatmanager](https://github.com/tomcatmanager)                     |
+| [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                 | [CrowdStrike](https://github.com/CrowdStrike)                         |
+| [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                  | [expliot_framework](https://gitlab.com/expliot_framework/)            |
+
+Possibly defunct but still good examples
+
+| Application Name                                                              | Description                                                                            | Organization or Author                                         |
+| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
+| [Katana](https://github.com/JohnHammond/katana)                               | Automatic CTF Challenge Solver                                                         | [John Hammond](https://github.com/JohnHammond)                 |
+| [SatanSword](https://github.com/Lucifer1993/SatanSword) (in Chinese)          | Comprehensive Penetration Framework for Red Teaming                                    | [Lucifer1993](https://github.com/Lucifer1993)                  |
+| [Jok3r](http://www.jok3r-framework.com)                                       | Network & Web Pentest Automation Framework                                             | [Koutto](https://github.com/koutto)                            |
+| [Counterfit](https://github.com/Azure/counterfit)                             | a CLI that provides a generic automation layer for assessing the security of ML models | [Microsoft Azure](https://github.com/Azure)                    |
+| [Overlord](https://github.com/qsecure-labs/overlord)                          | Red Teaming Infrastructure Automation                                                  | [QSecure Labs](https://github.com/qsecure-labs)                |
+| [Automated Reconnaissance Pipeline](https://github.com/epi052/recon-pipeline) | An automated target reconnaissance pipeline                                            | [epi052](https://github.com/epi052)                            |
+| [JSShell](https://github.com/Den1al/JSShell)                                  | An interactive multi-user web JavaScript (JS) shell                                    | [Den1al](https://github.com/Den1al)                            |
+| [RedShell](https://github.com/Verizon/redshell)                               | An interactive command prompt for red teaming and pentesting                           | [Verizon](https://github.com/Verizon)                          |
+| [FLASHMINGO](https://github.com/mandiant/flashmingo)                          | Automatic analysis of SWF files based on some heuristics. Extensible via plugins.      | [Mandiant](https://github.com/mandiant)                        |
+| [psiTurk](https://github.com/NYUCCL/psiTurk)                                  | An open platform for science on Amazon Mechanical Turk                                 | [NYU Computation and Cognition Lab](https://github.com/NYUCCL) |
+
+Note: If you have created an application based on `cmd2` that you would like us to mention here, please get in touch.

cmd2-2.5.9.dist-info/RECORD

@@ -0,0 +1,24 @@
+cmd2/__init__.py,sha256=C6IHJ_uHgkqejuRwA10IK0-OzPxHKyZbPn82nMUwn-A,2602
+cmd2/ansi.py,sha256=_3gAbMgqh8ksg43N2xQLp2u8uoB81BUl3CFoBN0990I,32036
+cmd2/argparse_completer.py,sha256=6z0zmODqM7vhQhI0c6JUvCmR2V4qfdWQEyTZeNIea8c,36505
+cmd2/argparse_custom.py,sha256=eZS-PodcF-UqhclKr61Wy0KXLRHM382Tk4T7mzlaWko,57689
+cmd2/clipboard.py,sha256=7EISono76d7djj17hbvR9cCTB7jVGSBkUjgVQiMyUjE,549
+cmd2/cmd2.py,sha256=GRIBAdRtDs2fXcUkE-IMaKIRLHV2slNbKTyPFq8QMHw,261090
+cmd2/command_definition.py,sha256=OscFEk-O2N20fb8_fhkczqclaCxOwYyxNTnXWXOlngg,7655
+cmd2/constants.py,sha256=DioxETv-_HzcMUnjuPyz7Cqw4YEt_MTrzOMotiHj-Jo,1981
+cmd2/decorators.py,sha256=QVRyGQmAM6YBUhlZHqEVAvt9Tn1NqKGeSjDrLoUHvJg,20261
+cmd2/exceptions.py,sha256=DwX7rQmon4eRyX1ZK4yne4lObdPO1j5Agg3Bav6pXwU,3600
+cmd2/history.py,sha256=4iFi0Bny1CTjMx0ByQplrElvlZcus3lUgj2IyBfvAf0,14988
+cmd2/parsing.py,sha256=58gD8hSvSV3nCliyoEZXJbvbzbnJ_5mSnwhTQhMM0BI,28297
+cmd2/plugin.py,sha256=CCzzuHeBQbxH7YuG3UCdQ0uArnKYbodjhj-sYCbXSa0,814
+cmd2/py.typed,sha256=qrkHrYJvGoZpU2BpVLNxJB44LlhqVSKyYOwD_L_1m3s,10
+cmd2/py_bridge.py,sha256=DJCa7ff-XLwcz7Ij47nrwxgDDVUIVS5bRReLmayok1Q,5016
+cmd2/rl_utils.py,sha256=HVPdNjuYyU67-XerPUJArmzhohzI1ABrZhU9cLc-EIs,11538
+cmd2/table_creator.py,sha256=qoxt9s3MxQkfSkp4cIPFMlVzC7kRjUU55p0ow7pFQus,47544
+cmd2/transcript.py,sha256=I0sD38RbG79Qz9GXIlfh1pHSNmWBTY2SLZAKEdSLWI4,9182
+cmd2/utils.py,sha256=TElD9YnN5yT7BNuUcKSLpqRLcxrVmx_etkKHETFxRWU,49366
+cmd2-2.5.9.dist-info/LICENSE,sha256=QXrW0Z0merk9mncyUkn-sgRxhT8_o1dL5HEaBNH47Q4,1099
+cmd2-2.5.9.dist-info/METADATA,sha256=l1ODgTmFJO7C1Lgro-FIdGMldbIOCHrvmilsRCSUml8,17103
+cmd2-2.5.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+cmd2-2.5.9.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
+cmd2-2.5.9.dist-info/RECORD,,

{cmd2-2.4.3.dist-info → cmd2-2.5.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any