Simplified some imports.

Author: kmvanbrunt

cmd2/argparse_custom.py

@@ -295,7 +295,7 @@ def get_items(self) -> list[CompletionItems]:
 )
 
 from . import constants
-from . import rich_utils as ru
+from .rich_utils import Cmd2Console
 from .styles import Cmd2Style
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -1113,12 +1113,12 @@ def __init__(
         max_help_position: int = 24,
         width: int | None = None,
         *,
-        console: ru.Cmd2Console | None = None,
+        console: Cmd2Console | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Cmd2HelpFormatter."""
         if console is None:
-            console = ru.Cmd2Console()
+            console = Cmd2Console()
 
         super().__init__(prog, indent_increment, max_help_position, width, console=console, **kwargs)
 

cmd2/string_utils.py

@@ -9,11 +9,7 @@
 from rich.align import AlignMethod
 from rich.style import StyleType
 
-from .rich_utils import (
-    console_width,
-    rich_text_to_string,
-    string_to_rich_text,
-)
+from . import rich_utils as ru
 
 
 def align(
@@ -33,11 +29,11 @@ def align(
 
     """
     if width is None:
-        width = console_width()
+        width = ru.console_width()
 
-    text = string_to_rich_text(val)
+    text = ru.string_to_rich_text(val)
     text.align(align, width=width, character=character)
-    return rich_text_to_string(text)
+    return ru.rich_text_to_string(text)
 
 
 def align_left(
@@ -92,9 +88,9 @@ def stylize(val: str, style: StyleType) -> str:
     :param style: style instance or style definition to apply.
     :return: the stylized string
     """
-    text = string_to_rich_text(val)
+    text = ru.string_to_rich_text(val)
     text.stylize(style)
-    return rich_text_to_string(text)
+    return ru.rich_text_to_string(text)
 
 
 def strip_style(val: str) -> str:
@@ -103,7 +99,7 @@ def strip_style(val: str) -> str:
     :param val: string which may contain ANSI style sequences
     :return: the same string with any ANSI style sequences removed
     """
-    text = string_to_rich_text(val)
+    text = ru.string_to_rich_text(val)
     return text.plain
 
 
@@ -116,7 +112,7 @@ def str_width(val: str) -> int:
     :param val: the string being measured
     :return: width of the string when printed to the terminal
     """
-    text = string_to_rich_text(val)
+    text = ru.string_to_rich_text(val)
     return text.cell_len
 
 

cmd2/terminal_utils.py

@@ -3,7 +3,7 @@
 These are used for things like setting the window title and asynchronous alerts.
 """
 
-from .string_utils import str_width
+from . import string_utils as su
 
 #######################################################
 # Common ANSI escape sequence constants
@@ -108,14 +108,14 @@ def async_alert_str(*, terminal_columns: int, prompt: str, line: str, cursor_off
     # That will be included in the input lines calculations since that is where the cursor is.
     num_prompt_terminal_lines = 0
     for prompt_line in prompt_lines[:-1]:
-        prompt_line_width = str_width(prompt_line)
+        prompt_line_width = su.str_width(prompt_line)
         num_prompt_terminal_lines += int(prompt_line_width / terminal_columns) + 1
 
     # Now calculate how many terminal lines are take up by the input
     last_prompt_line = prompt_lines[-1]
-    last_prompt_line_width = str_width(last_prompt_line)
+    last_prompt_line_width = su.str_width(last_prompt_line)
 
-    input_width = last_prompt_line_width + str_width(line)
+    input_width = last_prompt_line_width + su.str_width(line)
 
     num_input_terminal_lines = int(input_width / terminal_columns) + 1
 

cmd2/transcript.py

@@ -18,8 +18,8 @@ class is used in cmd2.py::run_transcript_tests()
     cast,
 )
 
+from . import string_utils as su
 from . import utils
-from .string_utils import strip_style
 
 if TYPE_CHECKING:  # pragma: no cover
     from cmd2 import (
@@ -74,13 +74,13 @@ def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
 
         line_num = 0
         finished = False
-        line = strip_style(next(transcript))
+        line = su.strip_style(next(transcript))
         line_num += 1
         while not finished:
             # Scroll forward to where actual commands begin
             while not line.startswith(self.cmdapp.visible_prompt):
                 try:
-                    line = strip_style(next(transcript))
+                    line = su.strip_style(next(transcript))
                 except StopIteration:
                     finished = True
                     break
@@ -106,14 +106,14 @@ def _test_transcript(self, fname: str, transcript: Iterator[str]) -> None:
             result = self.cmdapp.stdout.read()
             stop_msg = 'Command indicated application should quit, but more commands in transcript'
             # Read the expected result from transcript
-            if strip_style(line).startswith(self.cmdapp.visible_prompt):
+            if su.strip_style(line).startswith(self.cmdapp.visible_prompt):
                 message = f'\nFile {fname}, line {line_num}\nCommand was:\n{command}\nExpected: (nothing)\nGot:\n{result}\n'
                 assert not result.strip(), message  # noqa: S101
                 # If the command signaled the application to quit there should be no more commands
                 assert not stop, stop_msg  # noqa: S101
                 continue
             expected_parts = []
-            while not strip_style(line).startswith(self.cmdapp.visible_prompt):
+            while not su.strip_style(line).startswith(self.cmdapp.visible_prompt):
                 expected_parts.append(line)
                 try:
                     line = next(transcript)

cmd2/utils.py

@@ -12,13 +12,27 @@
 import subprocess
 import sys
 import threading
-from collections.abc import Callable, Iterable
+from collections.abc import (
+    Callable,
+    Iterable,
+)
 from difflib import SequenceMatcher
 from enum import Enum
-from typing import TYPE_CHECKING, Any, TextIO, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TextIO,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from . import constants
-from .argparse_custom import ChoicesProviderFunc, CompleterFunc
+from . import string_utils as su
+from .argparse_custom import (
+    ChoicesProviderFunc,
+    CompleterFunc,
+)
 
 if TYPE_CHECKING:  # pragma: no cover
     import cmd2  # noqa: F401
@@ -188,9 +202,7 @@ def alphabetical_sort(list_to_sort: Iterable[str]) -> list[str]:
     :param list_to_sort: the list being sorted
     :return: the sorted list
     """
-    from .string_utils import norm_fold
-
-    return sorted(list_to_sort, key=norm_fold)
+    return sorted(list_to_sort, key=su.norm_fold)
 
 
 def try_int_or_force_to_lower_case(input_str: str) -> int | str:
@@ -199,12 +211,10 @@ def try_int_or_force_to_lower_case(input_str: str) -> int | str:
     :param input_str: string to convert
     :return: the string as an integer or a lower case version of the string.
     """
-    from .string_utils import norm_fold
-
     try:
         return int(input_str)
     except ValueError:
-        return norm_fold(input_str)
+        return su.norm_fold(input_str)
 
 
 def natural_keys(input_str: str) -> list[int | str]:
@@ -238,11 +248,9 @@ def quote_specific_tokens(tokens: list[str], tokens_to_quote: list[str]) -> None
     :param tokens: token list being edited
     :param tokens_to_quote: the tokens, which if present in tokens, to quote
     """
-    from .string_utils import quote
-
     for i, token in enumerate(tokens):
         if token in tokens_to_quote:
-            tokens[i] = quote(token)
+            tokens[i] = su.quote(token)
 
 
 def unquote_specific_tokens(tokens: list[str], tokens_to_unquote: list[str]) -> None:
@@ -251,10 +259,8 @@ def unquote_specific_tokens(tokens: list[str], tokens_to_unquote: list[str]) ->
     :param tokens: token list being edited
     :param tokens_to_unquote: the tokens, which if present in tokens, to unquote
     """
-    from .string_utils import strip_quotes
-
     for i, token in enumerate(tokens):
-        unquoted_token = strip_quotes(token)
+        unquoted_token = su.strip_quotes(token)
         if unquoted_token in tokens_to_unquote:
             tokens[i] = unquoted_token
 
@@ -264,12 +270,10 @@ def expand_user(token: str) -> str:
 
     :param token: the string to expand
     """
-    from .string_utils import is_quoted, strip_quotes
-
     if token:
-        if is_quoted(token):
+        if su.is_quoted(token):
             quote_char = token[0]
-            token = strip_quotes(token)
+            token = su.strip_quotes(token)
         else:
             quote_char = ''