Added prompt-toolkit version of the app theme which remains synchronized when theme is updated.

Author: kmvanbrunt

CHANGELOG.md

@@ -155,8 +155,6 @@ prompt is displayed.
     - Added `Cmd2ArgumentParser.output_to()` context manager to temporarily set the output stream
       during `argparse` operations. This is helpful for directing output for functions like
       `parse_args()`, which default to `sys.stdout` and lack a `file` argument.
-    - Added `cmd2.rich_utils.register_theme_update_callback` function to register callback functions
-      to get called whenever `cmd2.rich_utils.set_theme` is called
     - Added ability to customize `prompt-toolkit` completion menu colors by overriding the following
       fields in the `cmd2` theme:
         - `Cmd2Style.COMPLETION_MENU` - Base style for the entire completion menu container (sets

cmd2/__init__.py

@@ -51,11 +51,16 @@
     RawDescriptionCmd2HelpFormatter,
     RawTextCmd2HelpFormatter,
     TextGroup,
-    get_theme,
-    set_theme,
 )
 from .string_utils import stylize
 from .styles import Cmd2Style
+from .theme import (
+    get_pt_theme,
+    get_theme,
+    register_pt_mapping,
+    register_synchronized_prefix,
+    set_theme,
+)
 from .utils import (
     CustomCompletionSettings,
     Settable,
@@ -100,16 +105,20 @@
     # Rich Utils
     "ArgumentDefaultsCmd2HelpFormatter",
     "Cmd2HelpFormatter",
-    "get_theme",
     "MetavarTypeCmd2HelpFormatter",
     "RawDescriptionCmd2HelpFormatter",
     "RawTextCmd2HelpFormatter",
-    "set_theme",
     "TextGroup",
     # String Utils
     "stylize",
-    # Styles,
+    # Styles
     "Cmd2Style",
+    # Theme
+    "get_pt_theme",
+    "get_theme",
+    "register_pt_mapping",
+    "register_synchronized_prefix",
+    "set_theme",
     # Utilities
     "categorize",
     "CustomCompletionSettings",

cmd2/cmd2.py

@@ -82,7 +82,6 @@
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession, choice, set_title
 from prompt_toolkit.styles import DynamicStyle
-from prompt_toolkit.styles import Style as PtStyle
 from rich.console import (
     Group,
     JustifyMethod,
@@ -162,6 +161,7 @@
     TextGroup,
 )
 from .styles import Cmd2Style
+from .theme import get_pt_theme
 from .types import (
     BoundCommandFunc,
     BoundCompleter,
@@ -195,7 +195,6 @@ def __init__(self, msg: str = "") -> None:
     Cmd2History,
     Cmd2Lexer,
     pt_filter_style,
-    rich_to_pt_style,
 )
 from .utils import (
     Settable,
@@ -526,11 +525,6 @@ def __init__(
         self._persistent_history_length = persistent_history_length
         self._initialize_history(persistent_history_file)
 
-        # Cache for prompt_toolkit completion menu styles
-        self.pt_style: PtStyle
-        self.update_pt_style()
-        ru.register_theme_update_callback(self.update_pt_style)
-
         # Create the main PromptSession
         self.bottom_toolbar = bottom_toolbar
         self.main_session = self._create_main_session(auto_suggest, completekey)
@@ -724,36 +718,6 @@ def _should_continue_multiline(self) -> bool:
                 # No macro found or already processed. The statement is complete.
                 return False
 
-    def update_pt_style(self) -> None:
-        """Update the cached prompt_toolkit style."""
-        theme = ru.get_theme()
-        rich_menu_style = theme.styles.get(Cmd2Style.COMPLETION_MENU, Style.null())
-        rich_completion_style = theme.styles.get(Cmd2Style.COMPLETION_MENU_COMPLETION, Style.null())
-        rich_current_style = theme.styles.get(Cmd2Style.COMPLETION_MENU_CURRENT, Style.null())
-        rich_meta_style = theme.styles.get(Cmd2Style.COMPLETION_MENU_META, Style.null())
-        rich_meta_current_style = theme.styles.get(Cmd2Style.COMPLETION_MENU_META_CURRENT, Style.null())
-
-        menu_style = rich_to_pt_style(rich_menu_style)
-        completion_style = rich_to_pt_style(rich_completion_style)
-        current_style = rich_to_pt_style(rich_current_style)
-        meta_style = rich_to_pt_style(rich_meta_style)
-        meta_current_style = rich_to_pt_style(rich_meta_current_style)
-
-        self.pt_style = PtStyle.from_dict(
-            {
-                "completion-menu": menu_style,
-                "completion-menu.completion": completion_style,
-                "completion-menu.completion.current": current_style,
-                "completion-menu.meta.completion": meta_style,
-                "completion-menu.meta.completion.current": meta_current_style,
-                "completion-menu.multi-column-meta": meta_current_style,
-            }
-        )
-
-    def _get_pt_style(self) -> "PtStyle":
-        """Return the cached prompt_toolkit style."""
-        return self.pt_style
-
     def _create_main_session(self, auto_suggest: bool, completekey: str) -> PromptSession[str]:
         """Create and return the main PromptSession for the application.
 
@@ -796,7 +760,7 @@ def _(event: Any) -> None:  # pragma: no cover
             "multiline": filters.Condition(self._should_continue_multiline),
             "prompt_continuation": self.continuation_prompt,
             "rprompt": self.get_rprompt,
-            "style": DynamicStyle(self._get_pt_style),
+            "style": DynamicStyle(get_pt_theme),
         }
 
         if self.stdin.isatty() and self.stdout.isatty():

cmd2/pt_utils.py

@@ -1,7 +1,6 @@
 """Utilities for integrating prompt_toolkit with cmd2."""
 
 import re
-import weakref
 from collections.abc import (
     Callable,
     Iterable,
@@ -111,16 +110,20 @@ def rich_to_pt_style(rich_style: StyleType) -> str:
 
     if rich_style.bold is not None:
         parts.append("bold" if rich_style.bold else "nobold")
-    if rich_style.italic is not None:
-        parts.append("italic" if rich_style.italic else "noitalic")
     if rich_style.underline is not None:
         parts.append("underline" if rich_style.underline else "nounderline")
+    if rich_style.strike is not None:
+        parts.append("strike" if rich_style.strike else "nostrike")
+    if rich_style.italic is not None:
+        parts.append("italic" if rich_style.italic else "noitalic")
     if rich_style.blink is not None:
         parts.append("blink" if rich_style.blink else "noblink")
     if rich_style.reverse is not None:
         parts.append("reverse" if rich_style.reverse else "noreverse")
     if rich_style.conceal is not None:
         parts.append("hidden" if rich_style.conceal else "nohidden")
+    if rich_style.dim is not None:
+        parts.append("dim" if rich_style.dim else "nodim")
     return " ".join(parts)
 
 
@@ -264,21 +267,16 @@ def clear(self) -> None:
         self._loaded_strings.clear()
 
 
-_lexers: "weakref.WeakSet[Cmd2Lexer]" = weakref.WeakSet()
-
-
-def _update_lexer_colors() -> None:
-    """Update colors for all active lexers."""
-    for lexer in _lexers:
-        lexer.set_colors()
-
-
-ru.register_theme_update_callback(_update_lexer_colors)
-
-
 class Cmd2Lexer(Lexer):
     """Lexer that highlights cmd2 command names, aliases, and macros."""
 
+    # Use the 'class:' prefix to look up styles in the prompt-toolkit theme
+    COMMAND_STYLE = f"class:{Cmd2Style.LEXER_COMMAND}"
+    ALIAS_STYLE = f"class:{Cmd2Style.LEXER_ALIAS}"
+    MACRO_STYLE = f"class:{Cmd2Style.LEXER_MACRO}"
+    FLAG_STYLE = f"class:{Cmd2Style.LEXER_FLAG}"
+    ARGUMENT_STYLE = f"class:{Cmd2Style.LEXER_ARGUMENT}"
+
     def __init__(
         self,
         cmd_app: "Cmd",
@@ -290,19 +288,6 @@ def __init__(
         super().__init__()
         self._cmd_app = cmd_app
 
-        _lexers.add(self)
-        self.set_colors()
-
-    def set_colors(self) -> None:
-        """Update colors from the current rich theme."""
-        # Retrieve styles dynamically from the current theme
-        theme = ru.get_theme()
-        self.command_color = rich_to_pt_style(theme.styles.get(Cmd2Style.LEXER_COMMAND, Style.null()))
-        self.alias_color = rich_to_pt_style(theme.styles.get(Cmd2Style.LEXER_ALIAS, Style.null()))
-        self.macro_color = rich_to_pt_style(theme.styles.get(Cmd2Style.LEXER_MACRO, Style.null()))
-        self.flag_color = rich_to_pt_style(theme.styles.get(Cmd2Style.LEXER_FLAG, Style.null()))
-        self.argument_color = rich_to_pt_style(theme.styles.get(Cmd2Style.LEXER_ARGUMENT, Style.null()))
-
     def lex_document(self, document: Document) -> Callable[[int], Any]:
         """Lex the document."""
         # Get redirection tokens and terminators to avoid highlighting them as values
@@ -319,9 +304,9 @@ def highlight_args(text: str, tokens: list[tuple[str, str]]) -> None:
                 if space:
                     tokens.append(("", match_text))
                 elif flag:
-                    tokens.append((self.flag_color, match_text))
+                    tokens.append((self.FLAG_STYLE, match_text))
                 elif (quoted or word) and match_text not in exclude_tokens:
-                    tokens.append((self.argument_color, match_text))
+                    tokens.append((self.ARGUMENT_STYLE, match_text))
                 else:
                     tokens.append(("", match_text))
 
@@ -355,23 +340,23 @@ def get_line(lineno: int) -> list[tuple[str, str]]:
                         for shortcut, _ in self._cmd_app.statement_parser.shortcuts:
                             if command.startswith(shortcut):
                                 # Add the shortcut with the command style
-                                tokens.append((self.command_color, shortcut))
+                                tokens.append((self.COMMAND_STYLE, shortcut))
 
                                 # If there's more in the command word, it's an argument
                                 if len(command) > len(shortcut):
-                                    tokens.append((self.argument_color, command[len(shortcut) :]))
+                                    tokens.append((self.ARGUMENT_STYLE, command[len(shortcut) :]))
 
                                 shortcut_found = True
                                 break
 
                         if not shortcut_found:
                             style = ""
                             if command in self._cmd_app.get_all_commands():
-                                style = self.command_color
+                                style = self.COMMAND_STYLE
                             elif command in self._cmd_app.aliases:
-                                style = self.alias_color
+                                style = self.ALIAS_STYLE
                             elif command in self._cmd_app.macros:
-                                style = self.macro_color
+                                style = self.MACRO_STYLE
 
                             # Add the command with the determined style
                             tokens.append((style, command))

cmd2/rich_utils.py

@@ -3,11 +3,7 @@
 import argparse
 import re
 import sys
-from collections.abc import (
-    Callable,
-    Iterator,
-    Mapping,
-)
+from collections.abc import Iterator
 from enum import Enum
 from typing import (
     IO,
@@ -48,7 +44,6 @@
 from . import constants
 from .styles import (
     DEFAULT_ARGPARSE_STYLES,
-    DEFAULT_CMD2_STYLES,
     Cmd2Style,
 )
 
@@ -59,6 +54,13 @@
 ANSI_STYLE_SEQUENCE_RE = re.compile(r"\x1b\[[0-9;]*m")
 
 
+def _get_theme() -> Theme:
+    """Retrieve the global Rich theme while avoiding circular imports."""
+    from .theme import get_theme
+
+    return get_theme()
+
+
 @runtime_checkable
 class HelpFormatterRenderable(Protocol):
     """Protocol for objects that require a Cmd2HelpFormatter to render."""
@@ -307,75 +309,6 @@ def __cmd2_argparse_help__(self, formatter: Cmd2HelpFormatter) -> Group:
         return Group(styled_title, indented_text)
 
 
-# The application-wide theme. Use get_theme() and set_theme() to access it.
-_APP_THEME: Theme | None = None
-
-# Callbacks to be executed when the theme is updated
-_theme_update_callbacks: list[Callable[[], None]] = []
-
-
-def register_theme_update_callback(callback: Callable[[], None]) -> None:
-    """Register a callback to be executed when the theme is updated."""
-    if callback not in _theme_update_callbacks:
-        _theme_update_callbacks.append(callback)
-
-
-def get_theme() -> Theme:
-    """Get the application-wide theme. Initializes it on the first call."""
-    global _APP_THEME  # noqa: PLW0603
-    if _APP_THEME is None:
-        _APP_THEME = _create_default_theme()
-    return _APP_THEME
-
-
-def set_theme(styles: Mapping[str, StyleType] | None = None) -> None:
-    """Set the Rich theme used by cmd2.
-
-    This function performs an in-place update of the existing theme's
-    styles. This ensures that any Console objects already using the theme
-    will reflect the changes immediately without needing to be recreated.
-
-    Call set_theme() with no arguments to reset to the default theme.
-    This will clear any custom styles that were previously applied.
-
-    :param styles: optional mapping of style names to styles
-    """
-    theme = get_theme()
-
-    # Start with a fresh copy of the default styles.
-    unparsed_styles: dict[str, StyleType] = {}
-    unparsed_styles.update(_create_default_theme().styles)
-
-    # Add the custom styles, which may contain unparsed strings
-    if styles is not None:
-        unparsed_styles.update(styles)
-
-    # Use Rich's Theme class to perform the parsing
-    parsed_styles = Theme(unparsed_styles).styles
-
-    # Perform the in-place update with the results
-    theme.styles.clear()
-    theme.styles.update(parsed_styles)
-
-    # Synchronize rich-argparse styles with the main application theme.
-    for name in Cmd2HelpFormatter.styles.keys() & theme.styles.keys():
-        Cmd2HelpFormatter.styles[name] = theme.styles[name]
-
-    # Notify callbacks that the theme has been updated
-    for callback in _theme_update_callbacks:
-        callback()
-
-
-def _create_default_theme() -> Theme:
-    """Create a default theme for the application.
-
-    This theme combines the default styles from cmd2, rich-argparse, and Rich.
-    """
-    app_styles = DEFAULT_CMD2_STYLES.copy()
-    app_styles.update(DEFAULT_ARGPARSE_STYLES)
-    return Theme(app_styles, inherit=True)
-
-
 class Cmd2BaseConsole(Console):
     """Base class for all cmd2 Rich consoles.
 
@@ -439,7 +372,7 @@ def __init__(
             color_system="truecolor" if allow_style else None,
             force_terminal=force_terminal,
             force_interactive=force_interactive,
-            theme=get_theme(),
+            theme=_get_theme(),
             **kwargs,
         )
 
@@ -460,7 +393,7 @@ def _build_config_key(
         return (
             id(file),
             ALLOW_STYLE,
-            id(get_theme()),
+            id(_get_theme()),
             tuple(sorted(kwargs.items())),
         )
 
@@ -677,7 +610,7 @@ def rich_text_to_string(text: Text) -> str:
         color_system="truecolor",
         soft_wrap=True,
         no_color=False,
-        theme=get_theme(),
+        theme=_get_theme(),
     )
     with console.capture() as capture:
         console.print(text, end="")