cmd2 2.6.0__py3-none-any.whl → 2.6.2__py3-none-any.whl

cmd2/cmd2.py

@@ -144,6 +144,7 @@ from .table_creator import (
 from .utils import (
     Settable,
     get_defining_class,
+    get_types,
     strip_doc_annotations,
     suggest_similar,
 )
@@ -253,17 +254,11 @@ class _CommandParsers:
             command = command_method.__name__[len(COMMAND_FUNC_PREFIX) :]
 
             parser_builder = getattr(command_method, constants.CMD_ATTR_ARGPARSER, None)
-            parent = self._cmd.find_commandset_for_command(command) or self._cmd
-            parser = self._cmd._build_parser(parent, parser_builder)
-            if parser is None:
+            if parser_builder is None:
                 return None
 
-            # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
-            from .decorators import (
-                _set_parser_prog,
-            )
-
-            _set_parser_prog(parser, command)
+            parent = self._cmd.find_commandset_for_command(command) or self._cmd
+            parser = self._cmd._build_parser(parent, parser_builder, command)
 
             # If the description has not been set, then use the method docstring if one exists
             if parser.description is None and hasattr(command_method, '__wrapped__') and command_method.__wrapped__.__doc__:
@@ -757,24 +752,41 @@ class Cmd(cmd.Cmd):
     def _build_parser(
         self,
         parent: CommandParent,
-        parser_builder: Optional[
-            Union[
-                argparse.ArgumentParser,
-                Callable[[], argparse.ArgumentParser],
-                StaticArgParseBuilder,
-                ClassArgParseBuilder,
-            ]
+        parser_builder: Union[
+            argparse.ArgumentParser,
+            Callable[[], argparse.ArgumentParser],
+            StaticArgParseBuilder,
+            ClassArgParseBuilder,
         ],
-    ) -> Optional[argparse.ArgumentParser]:
-        parser: Optional[argparse.ArgumentParser] = None
+        prog: str,
+    ) -> argparse.ArgumentParser:
+        """Build argument parser for a command/subcommand.
+
+        :param parent: CommandParent object which owns the command using the parser.
+                       This function assumes that parent is where parser_builder
+                       is defined when parser_builder is a classmethod.
+        :param parser_builder: means used to build the parser
+        :param prog: prog value to set in new parser
+        :return: new parser
+        :raises TypeError: if parser_builder is invalid type
+        """
         if isinstance(parser_builder, staticmethod):
             parser = parser_builder.__func__()
         elif isinstance(parser_builder, classmethod):
-            parser = parser_builder.__func__(parent if not None else self)  # type: ignore[arg-type]
+            parser = parser_builder.__func__(parent.__class__)
         elif callable(parser_builder):
             parser = parser_builder()
         elif isinstance(parser_builder, argparse.ArgumentParser):
             parser = copy.deepcopy(parser_builder)
+        else:
+            raise TypeError(f"Invalid type for parser_builder: {type(parser_builder)}")
+
+        from .decorators import (
+            _set_parser_prog,
+        )
+
+        _set_parser_prog(parser, prog)
+
         return parser
 
     def _install_command_function(self, command_func_name: str, command_method: CommandFunc, context: str = '') -> None:
@@ -962,12 +974,7 @@ class Cmd(cmd.Cmd):
 
             target_parser = find_subcommand(command_parser, subcommand_names)
 
-            subcmd_parser = cast(argparse.ArgumentParser, self._build_parser(cmdset, subcmd_parser_builder))
-            from .decorators import (
-                _set_parser_prog,
-            )
-
-            _set_parser_prog(subcmd_parser, f'{command_name} {subcommand_name}')
+            subcmd_parser = self._build_parser(cmdset, subcmd_parser_builder, f'{command_name} {subcommand_name}')
             if subcmd_parser.description is None and method.__doc__:
                 subcmd_parser.description = strip_doc_annotations(method.__doc__)
 
@@ -2609,7 +2616,7 @@ class Cmd(cmd.Cmd):
                 # caused by certain binary characters having been printed to it.
                 import subprocess
 
-                proc = subprocess.Popen(['stty', 'sane'])  # noqa: S603, S607
+                proc = subprocess.Popen(['stty', 'sane'])  # noqa: S607
                 proc.communicate()
 
         data = plugin.CommandFinalizationData(stop, statement)
@@ -3597,8 +3604,8 @@ class Cmd(cmd.Cmd):
         max_arg_num = 0
         arg_nums = set()
 
-        while True:
-            try:
+        try:
+            while True:
                 cur_match = normal_matches.__next__()
 
                 # Get the number string between the braces
@@ -3612,9 +3619,8 @@ class Cmd(cmd.Cmd):
                 max_arg_num = max(max_arg_num, cur_num)
 
                 arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=False))
-
-            except StopIteration:
-                break
+        except StopIteration:
+            pass
 
         # Make sure the argument numbers are continuous
         if len(arg_nums) != max_arg_num:
@@ -3624,16 +3630,16 @@ class Cmd(cmd.Cmd):
         # Find all escaped arguments
         escaped_matches = re.finditer(MacroArg.macro_escaped_arg_pattern, value)
 
-        while True:
-            try:
+        try:
+            while True:
                 cur_match = escaped_matches.__next__()
 
                 # Get the number string between the braces
                 cur_num_str = re.findall(MacroArg.digit_pattern, cur_match.group())[0]
 
                 arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=True))
-            except StopIteration:
-                break
+        except StopIteration:
+            pass
 
         # Set the macro
         result = "overwritten" if args.name in self.macros else "created"
@@ -5545,10 +5551,10 @@ class Cmd(cmd.Cmd):
     def _validate_prepostloop_callable(cls, func: Callable[[], None]) -> None:
         """Check parameter and return types for preloop and postloop hooks."""
         cls._validate_callable_param_count(func, 0)
-        # make sure there is no return notation
-        signature = inspect.signature(func)
-        if signature.return_annotation is not None:
-            raise TypeError(f"{func.__name__} must declare return a return type of 'None'")
+        # make sure there is no return annotation or the return is specified as None
+        _, ret_ann = get_types(func)
+        if ret_ann is not None:
+            raise TypeError(f"{func.__name__} must have a return type of 'None', got: {ret_ann}")
 
     def register_preloop_hook(self, func: Callable[[], None]) -> None:
         """Register a function to be called at the beginning of the command loop."""
@@ -5564,11 +5570,13 @@ class Cmd(cmd.Cmd):
     def _validate_postparsing_callable(cls, func: Callable[[plugin.PostparsingData], plugin.PostparsingData]) -> None:
         """Check parameter and return types for postparsing hooks."""
         cls._validate_callable_param_count(cast(Callable[..., Any], func), 1)
-        signature = inspect.signature(func)
-        _, param = next(iter(signature.parameters.items()))
-        if param.annotation != plugin.PostparsingData:
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: 'cmd2.plugin.PostparsingData'")
+        par_ann = next(iter(type_hints.values()))
+        if par_ann != plugin.PostparsingData:
             raise TypeError(f"{func.__name__} must have one parameter declared with type 'cmd2.plugin.PostparsingData'")
-        if signature.return_annotation != plugin.PostparsingData:
+        if ret_ann != plugin.PostparsingData:
             raise TypeError(f"{func.__name__} must declare return a return type of 'cmd2.plugin.PostparsingData'")
 
     def register_postparsing_hook(self, func: Callable[[plugin.PostparsingData], plugin.PostparsingData]) -> None:
@@ -5583,21 +5591,21 @@ class Cmd(cmd.Cmd):
         cls, func: Callable[[CommandDataType], CommandDataType], data_type: type[CommandDataType]
     ) -> None:
         """Check parameter and return types for pre and post command hooks."""
-        signature = inspect.signature(func)
         # validate that the callable has the right number of parameters
         cls._validate_callable_param_count(cast(Callable[..., Any], func), 1)
+
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: {data_type}")
+        param_name, par_ann = next(iter(type_hints.items()))
         # validate the parameter has the right annotation
-        paramname = next(iter(signature.parameters.keys()))
-        param = signature.parameters[paramname]
-        if param.annotation != data_type:
-            raise TypeError(f'argument 1 of {func.__name__} has incompatible type {param.annotation}, expected {data_type}')
+        if par_ann != data_type:
+            raise TypeError(f'argument 1 of {func.__name__} has incompatible type {par_ann}, expected {data_type}')
         # validate the return value has the right annotation
-        if signature.return_annotation == signature.empty:
+        if ret_ann is None:
             raise TypeError(f'{func.__name__} does not have a declared return type, expected {data_type}')
-        if signature.return_annotation != data_type:
-            raise TypeError(
-                f'{func.__name__} has incompatible return type {signature.return_annotation}, expected {data_type}'
-            )
+        if ret_ann != data_type:
+            raise TypeError(f'{func.__name__} has incompatible return type {ret_ann}, expected {data_type}')
 
     def register_precmd_hook(self, func: Callable[[plugin.PrecommandData], plugin.PrecommandData]) -> None:
         """Register a hook to be called before the command function."""
@@ -5615,12 +5623,16 @@ class Cmd(cmd.Cmd):
     ) -> None:
         """Check parameter and return types for command finalization hooks."""
         cls._validate_callable_param_count(func, 1)
-        signature = inspect.signature(func)
-        _, param = next(iter(signature.parameters.items()))
-        if param.annotation != plugin.CommandFinalizationData:
-            raise TypeError(f"{func.__name__} must have one parameter declared with type {plugin.CommandFinalizationData}")
-        if signature.return_annotation != plugin.CommandFinalizationData:
-            raise TypeError("{func.__name__} must declare return a return type of {plugin.CommandFinalizationData}")
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: {plugin.CommandFinalizationData}")
+        _, par_ann = next(iter(type_hints.items()))
+        if par_ann != plugin.CommandFinalizationData:
+            raise TypeError(
+                f"{func.__name__} must have one parameter declared with type {plugin.CommandFinalizationData}, got: {par_ann}"
+            )
+        if ret_ann != plugin.CommandFinalizationData:
+            raise TypeError(f"{func.__name__} must declare return a return type of {plugin.CommandFinalizationData}")
 
     def register_cmdfinalization_hook(
         self, func: Callable[[plugin.CommandFinalizationData], plugin.CommandFinalizationData]

cmd2/decorators.py

@@ -393,6 +393,14 @@ def with_argparser(
 
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX) :]
 
+        if isinstance(parser, argparse.ArgumentParser):
+            # Set parser's prog value for backward compatibility within the cmd2 2.0 family.
+            # This will be removed in cmd2 3.0 since we never reference this parser object's prog value.
+            # Since it's possible for the same parser object to be passed into multiple with_argparser()
+            # calls, we only set prog on the deep copies of this parser based on the specific do_xxxx
+            # instance method they are associated with.
+            _set_parser_prog(parser, command_name)
+
         # Set some custom attributes for this command
         setattr(cmd_wrapper, constants.CMD_ATTR_ARGPARSER, parser)
         setattr(cmd_wrapper, constants.CMD_ATTR_PRESERVE_QUOTES, preserve_quotes)

cmd2/utils.py

@@ -14,29 +14,12 @@ import sys
 import threading
 import unicodedata
 from collections.abc import Callable, Iterable
-from difflib import (
-    SequenceMatcher,
-)
-from enum import (
-    Enum,
-)
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Optional,
-    TextIO,
-    TypeVar,
-    Union,
-    cast,
-)
-
-from . import (
-    constants,
-)
-from .argparse_custom import (
-    ChoicesProviderFunc,
-    CompleterFunc,
-)
+from difflib import SequenceMatcher
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional, TextIO, TypeVar, Union, cast, get_type_hints
+
+from . import constants
+from .argparse_custom import ChoicesProviderFunc, CompleterFunc
 
 if TYPE_CHECKING:  # pragma: no cover
     import cmd2  # noqa: F401
@@ -1261,3 +1244,27 @@ def suggest_similar(
             best_simil = simil
             proposed_command = each
     return proposed_command
+
+
+def get_types(func_or_method: Callable[..., Any]) -> tuple[dict[str, Any], Any]:
+    """Use typing.get_type_hints() to extract type hints for parameters and return value.
+
+    This exists because the inspect module doesn't have a safe way of doing this that works
+    both with and without importing annotations from __future__ until Python 3.10.
+
+    TODO: Once cmd2 only supports Python 3.10+, change to use inspect.get_annotations(eval_str=True)
+
+    :param func_or_method: Function or method to return the type hints for
+    :return tuple with first element being dictionary mapping param names to type hints
+            and second element being return type hint, unspecified, returns None
+    """
+    try:
+        type_hints = get_type_hints(func_or_method)  # Get dictionary of type hints
+    except TypeError as exc:
+        raise ValueError("Argument passed to get_types should be a function or method") from exc
+    ret_ann = type_hints.pop('return', None)  # Pop off the return annotation if it exists
+    if inspect.ismethod(func_or_method):
+        type_hints.pop('self', None)  # Pop off `self` hint for methods
+    if ret_ann is type(None):
+        ret_ann = None  # Simplify logic to just return None instead of NoneType
+    return type_hints, ret_ann

{cmd2-2.6.0.dist-info → cmd2-2.6.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 2.6.0
+Version: 2.6.2
 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
+        Copyright (c) 2008-2025 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
@@ -39,6 +39,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -80,22 +81,22 @@ when using cmd.
 
 ![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:
+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
@@ -104,8 +105,8 @@ workflow tool. `cmd2` pulls off this flexibility based on two pillars of philoso
 
 <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.
+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.
@@ -116,13 +117,15 @@ command discovery'. The following is a list of features in this category.
 
 <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.
+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`
+- 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
 
@@ -132,11 +135,12 @@ On all operating systems, the latest stable version of `cmd2` can be installed u
 pip install -U cmd2
 ```
 
-cmd2 works with Python 3.9+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
+cmd2 works with Python 3.9+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party
+dependencies. It works with both conventional CPython and free-threaded variants.
 
 For information on other installation options, see
-[Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
-documentation.
+[Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the
+cmd2 documentation.
 
 ## Documentation
 
@@ -144,7 +148,8 @@ The latest documentation for cmd2 can be read online here: https://cmd2.readthed
 
 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.
+The best way to learn the cmd2 api is to delve into the example applications located in source under
+examples.
 
 ## Tutorials
 
@@ -153,13 +158,15 @@ The best way to learn the cmd2 api is to delve into the example applications loc
     - [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
+    - 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
+    - More complex examples that demonstrate more featuers about how to put together a complete
+      application
 
 ## Hello World
 
@@ -187,10 +194,10 @@ if __name__ == '__main__':
 
 ## 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:
+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
@@ -232,4 +239,5 @@ Possibly defunct but still good examples
 | [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.
+Note: If you have created an application based on `cmd2` that you would like us to mention here,
+please get in touch.

{cmd2-2.6.0.dist-info → cmd2-2.6.2.dist-info}/RECORD

@@ -3,10 +3,10 @@ cmd2/ansi.py,sha256=XwBvFnB51LYYjIpfEge6mcr5X63dUxiV0aJlOOJ_2tQ,31965
 cmd2/argparse_completer.py,sha256=F_5hiX9fYpEhV42mz7v7qeS7KuInAS6xU6KekLxYzsQ,35863
 cmd2/argparse_custom.py,sha256=Q7N-2TSctfjn3TEZezQNaT5y0w8sdGpmUA5_DCPa_Pk,59131
 cmd2/clipboard.py,sha256=HLZWY-W3mkpF_OqQet-F8pS3rlXpiE5vxUyPV_yHvIU,507
-cmd2/cmd2.py,sha256=7U-uTdWSMumFjvDIYUvd5V0Bg87Av9V4yG-aODUTr-Q,261285
+cmd2/cmd2.py,sha256=-LkAwuakQGF_oZTUsmtQfPTILtCT-F7LNE7Ej2l9PVc,261740
 cmd2/command_definition.py,sha256=_wF39nig5MP0grSOZ1hFehP5fCGusUNHMn9PIs6pmcU,7648
 cmd2/constants.py,sha256=duEqGhhvdUV7AYxE8VGZ4wyFBcN2y2bLPd5iefW4tSU,1943
-cmd2/decorators.py,sha256=9Jiml8HGc-UyUtWTns3TwW8ZHte4NchfGgHe-_1CcDM,20075
+cmd2/decorators.py,sha256=t0gBy3aRz5ke0jHyP5YOszdQ61t5aV8j0eNyLPX6hmg,20644
 cmd2/exceptions.py,sha256=fYciAnLCpvPYkXCtmADhxtcvjbxVagRjhp41eYwAQo8,3444
 cmd2/history.py,sha256=elJPuvV7BnUEgpWnixNyl2yGtR6sz3nwvpyFwaeFqRA,14800
 cmd2/parsing.py,sha256=BsyQTTkuEg4FiQP9o2O28KjXodFgXkXmvk_VkAe-Ryw,28057
@@ -16,9 +16,9 @@ cmd2/py_bridge.py,sha256=TKl2d7sgptDdccuO1PWG8m83Nww2bGCzsY4_wqjKTjg,4935
 cmd2/rl_utils.py,sha256=sWapqwDR_GvOgy5NJ7c-i6nUU4dqpKpGQ8-Olwi3tuU,11335
 cmd2/table_creator.py,sha256=nF3VEgGHvfhHBh_yoMAiV1WaDdR8hIareIAogzIPq5M,47177
 cmd2/transcript.py,sha256=Ws0lW_oBFxCQCKSwvnDUS1x3ya163YXnV-O5aTU0z7k,9207
-cmd2/utils.py,sha256=vY4JdnTbKJ2nhkDva_4Jiw1RY7eOoqkcinP6sVhgLyU,49486
-cmd2-2.6.0.dist-info/licenses/LICENSE,sha256=QXrW0Z0merk9mncyUkn-sgRxhT8_o1dL5HEaBNH47Q4,1099
-cmd2-2.6.0.dist-info/METADATA,sha256=k_YfbO5kXJByal_dPlrs6B3dbtKI1DizrDoX8Qd5xzc,17133
-cmd2-2.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cmd2-2.6.0.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
-cmd2-2.6.0.dist-info/RECORD,,
+cmd2/utils.py,sha256=NqDIkY4LiAlnv_Un7MFHxszoH2KgEWQ7NJOwQurIn_E,50698
+cmd2-2.6.2.dist-info/licenses/LICENSE,sha256=9qPeHY4u2fkSz0JQGT-P4T3QqTWTqnQJ_8LkZUhSdFY,1099
+cmd2-2.6.2.dist-info/METADATA,sha256=PXmEeU5Cspekoxefr9LjKqHJ44zXV4hUdwGUrBTeygs,17292
+cmd2-2.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cmd2-2.6.2.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
+cmd2-2.6.2.dist-info/RECORD,,

{cmd2-2.6.0.dist-info → cmd2-2.6.2.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2008-2024 Catherine Devlin and others
+Copyright (c) 2008-2025 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