Each CommandSet's settables are defined separately. cmd2.Cmd searches all registered CommandSets for settables.

Settables can now set any attribute on any object passed to it. The name the user sees may be set to a different value
than what the actual attribute is.
Cmd2 will now aggregate all settables on the cmd2.Cmd instance with each installed CommandSet.

Author: anselor

cmd2/cmd2.py

@@ -308,9 +308,14 @@ def __init__(
         self.max_completion_items = 50
 
         # A dictionary mapping settable names to their Settable instance
-        self.settables: Dict[str, Settable] = dict()
+        self._settables: Dict[str, Settable] = dict()
+        self.always_prefix_settables: bool = False
         self.build_settables()
 
+        # CommandSet containers
+        self._installed_command_sets: List[CommandSet] = []
+        self._cmd_to_command_sets: Dict[str, CommandSet] = {}
+
         # Use as prompt for multiline commands on the 2nd+ line of input
         self.continuation_prompt = '> '
 
@@ -500,8 +505,6 @@ def __init__(
         # depends on them and it's possible a module's on_register() method may need to access some.
         ############################################################################################################
         # Load modular commands
-        self._installed_command_sets: List[CommandSet] = []
-        self._cmd_to_command_sets: Dict[str, CommandSet] = {}
         if command_sets:
             for command_set in command_sets:
                 self.register_command_set(command_set)
@@ -575,6 +578,15 @@ def register_command_set(self, cmdset: CommandSet) -> None:
         if type(cmdset) in existing_commandset_types:
             raise CommandSetRegistrationError('CommandSet ' + type(cmdset).__name__ + ' is already installed')
 
+        if self.always_prefix_settables:
+            if len(cmdset.settable_prefix.strip()) == 0:
+                raise CommandSetRegistrationError('CommandSet settable prefix must not be empty')
+        else:
+            all_settables = self.settables
+            for key in cmdset.settables.keys():
+                if key in all_settables:
+                    raise KeyError(f'Duplicate settable {key} is already registered')
+
         cmdset.on_register(self)
         methods = inspect.getmembers(
             cmdset,
@@ -888,13 +900,27 @@ def _unregister_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
                     action.remove_parser(subcommand_name)
                     break
 
+    @property
+    def settables(self) -> Mapping[str, Settable]:
+        all_settables = dict(self._settables)
+        for cmd_set in self._installed_command_sets:
+            cmdset_settables = cmd_set.settables
+            for settable_name, settable in cmdset_settables.items():
+                if self.always_prefix_settables:
+                    all_settables[f'{cmd_set.settable_prefix}.{settable_name}'] = settable
+                else:
+                    all_settables[settable_name] = settable
+        return all_settables
+
     def add_settable(self, settable: Settable) -> None:
         """
         Convenience method to add a settable parameter to ``self.settables``
 
         :param settable: Settable object being added
         """
-        self.settables[settable.name] = settable
+        if settable.settable_obj is None:
+            settable.settable_obj = self
+        self._settables[settable.name] = settable
 
     def remove_settable(self, name: str) -> None:
         """
@@ -904,7 +930,7 @@ def remove_settable(self, name: str) -> None:
         :raises: KeyError if the Settable matches this name
         """
         try:
-            del self.settables[name]
+            del self._settables[name]
         except KeyError:
             raise KeyError(name + " is not a settable parameter")
 
@@ -3712,29 +3738,23 @@ def do_set(self, args: argparse.Namespace) -> None:
         if args.param:
             try:
                 settable = self.settables[args.param]
+                if settable.settable_obj is None:
+                    settable.settable_obj = self
             except KeyError:
                 self.perror("Parameter '{}' not supported (type 'set' for list of parameters).".format(args.param))
                 return
 
             if args.value:
-                args.value = utils.strip_quotes(args.value)
-
                 # Try to update the settable's value
                 try:
-                    orig_value = getattr(self, args.param)
-                    setattr(self, args.param, settable.val_type(args.value))
-                    new_value = getattr(self, args.param)
+                    orig_value = settable.get_value()
+                    new_value = settable.set_value(utils.strip_quotes(args.value))
                 # noinspection PyBroadException
                 except Exception as e:
                     err_msg = "Error setting {}: {}".format(args.param, e)
                     self.perror(err_msg)
-                    return
-
-                self.poutput('{} - was: {!r}\nnow: {!r}'.format(args.param, orig_value, new_value))
-
-                # Check if we need to call an onchange callback
-                if orig_value != new_value and settable.onchange_cb:
-                    settable.onchange_cb(args.param, orig_value, new_value)
+                else:
+                    self.poutput('{} - was: {!r}\nnow: {!r}'.format(args.param, orig_value, new_value))
                 return
 
             # Show one settable
@@ -3747,7 +3767,8 @@ def do_set(self, args: argparse.Namespace) -> None:
         max_len = 0
         results = dict()
         for param in to_show:
-            results[param] = '{}: {!r}'.format(param, getattr(self, param))
+            settable = self.settables[param]
+            results[param] = '{}: {!r}'.format(param, settable.get_value())
             max_len = max(max_len, ansi.style_aware_wcswidth(results[param]))
 
         # Display the results
@@ -5131,7 +5152,7 @@ def _resolve_func_self(self, cmd_support_func: Callable, cmd_self: Union[Command
         :return:
         """
         # figure out what class the command support function was defined in
-        func_class = get_defining_class(cmd_support_func)
+        func_class = get_defining_class(cmd_support_func)  # type: Optional[Type]
 
         # Was there a defining class identified? If so, is it a sub-class of CommandSet?
         if func_class is not None and issubclass(func_class, CommandSet):

cmd2/command_definition.py

@@ -3,6 +3,8 @@
 Supports the definition of commands in separate classes to be composed into cmd2.Cmd
 """
 from typing import (
+    Dict,
+    Mapping,
     Optional,
     Type,
 )
@@ -14,6 +16,9 @@
 from .exceptions import (
     CommandSetRegistrationError,
 )
+from .utils import (
+    Settable,
+)
 
 # Allows IDEs to resolve types without impacting imports at runtime, breaking circular dependency issues
 try:  # pragma: no cover
@@ -90,6 +95,8 @@ class CommandSet(object):
 
     def __init__(self):
         self._cmd: Optional[cmd2.Cmd] = None
+        self._settables: Dict[str, Settable] = {}
+        self._settable_prefix = self.__class__.__name__
 
     def on_register(self, cmd) -> None:
         """
@@ -126,3 +133,36 @@ def on_unregistered(self) -> None:
         Subclasses can override this to perform remaining cleanup steps.
         """
         self._cmd = None
+
+    @property
+    def settable_prefix(self) -> str:
+        return self._settable_prefix
+
+    @property
+    def settables(self) -> Mapping[str, Settable]:
+        return self._settables
+
+    def add_settable(self, settable: Settable) -> None:
+        """
+        Convenience method to add a settable parameter to the CommandSet
+
+        :param settable: Settable object being added
+        """
+        if self._cmd and not self._cmd.always_prefix_settables:
+            if settable.name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
+                raise KeyError(f'Duplicate settable: {settable.name}')
+        if settable.settable_obj is None:
+            settable.settable_obj = self
+        self._settables[settable.name] = settable
+
+    def remove_settable(self, name: str) -> None:
+        """
+        Convenience method for removing a settable parameter from the CommandSet
+
+        :param name: name of the settable being removed
+        :raises: KeyError if the Settable matches this name
+        """
+        try:
+            del self._settables[name]
+        except KeyError:
+            raise KeyError(name + " is not a settable parameter")

cmd2/utils.py

@@ -28,13 +28,15 @@
     Optional,
     TextIO,
     Type,
+    TYPE_CHECKING, 
     Union,
 )
 
 from . import (
     constants,
 )
-
+if TYPE_CHECKING:  # pragma: no cover
+    import cmd2
 
 def is_quoted(arg: str) -> bool:
     """
@@ -93,14 +95,16 @@ def str_to_bool(val: str) -> bool:
 
 
 class Settable:
-    """Used to configure a cmd2 instance member to be settable via the set command in the CLI"""
+    """Used to configure an attribute to be settable via the set command in the CLI"""
 
     def __init__(
         self,
         name: str,
         val_type: Callable,
         description: str,
         *,
+        settable_object: Optional[object] = None,
+        settable_attrib_name: Optional[str] = None,
         onchange_cb: Callable[[str, Any, Any], Any] = None,
         choices: Iterable = None,
         choices_provider: Optional[Callable] = None,
@@ -114,6 +118,8 @@ def __init__(
                          even validate its value. Setting this to bool provides tab completion for true/false and
                          validation using str_to_bool(). The val_type function should raise an exception if it fails.
                          This exception will be caught and printed by Cmd.do_set().
+        :param settable_object: Object to configure with the set command
+        :param settable_attrib_name: Attribute name to be modified. Defaults to `name` if not specified.
         :param description: string describing this setting
         :param onchange_cb: optional function or method to call when the value of this settable is altered
                             by the set command. (e.g. onchange_cb=self.debug_changed)
@@ -137,11 +143,36 @@ def __init__(
         self.name = name
         self.val_type = val_type
         self.description = description
+        self.settable_obj = settable_object
+        self.settable_attrib_name = settable_attrib_name if settable_attrib_name is not None else name
         self.onchange_cb = onchange_cb
         self.choices = choices
         self.choices_provider = choices_provider
         self.completer = completer
 
+    def get_value(self) -> Any:
+        """
+        Get the value of the settable attribute
+        :return:
+        """
+        return getattr(self.settable_obj, self.settable_attrib_name)
+
+    def set_value(self, value: Any) -> Any:
+        """
+        Set the settable attribute on the specified destination object
+        :param value: New value to set
+        :return: New value that the attribute was set to
+        """
+        # Try to update the settable's value
+        orig_value = self.get_value()
+        setattr(self.settable_obj, self.settable_attrib_name, self.val_type(value))
+        new_value = getattr(self.settable_obj, self.settable_attrib_name)
+
+        # 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 namedtuple_with_defaults(typename: str, field_names: Union[str, List[str]], default_values: collections_abc.Iterable = ()):
     """

tests/test_cmd2.py

@@ -176,7 +176,7 @@ def test_set_not_supported(base_app):
 
 
 def test_set_no_settables(base_app):
-    base_app.settables = {}
+    base_app._settables.clear()
     out, err = run_cmd(base_app, 'set quiet True')
     expected = normalize("There are no settable parameters")
     assert err == expected
@@ -229,11 +229,10 @@ def onchange_app():
 
 def test_set_onchange_hook(onchange_app):
     out, err = run_cmd(onchange_app, 'set quiet True')
-    expected = normalize(
-        """
+    expected = normalize("""
+You changed quiet
 quiet - was: False
 now: True
-You changed quiet
 """
     )
     assert out == expected