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

cmd2/py_bridge.py

@@ -1,7 +1,6 @@
-# coding=utf-8
-"""
-Bridges calls made inside of a Python environment to the Cmd2 host app
-while maintaining a reasonable degree of isolation between the two.
+"""Bridges calls made inside of a Python environment to the Cmd2 host app.
+
+Maintains a reasonable degree of isolation between the two.
 """
 
 import sys
@@ -13,7 +12,6 @@ from typing import (
     IO,
     TYPE_CHECKING,
     Any,
-    List,
     NamedTuple,
     Optional,
     TextIO,
@@ -30,7 +28,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 class CommandResult(NamedTuple):
-    """Encapsulates the results from a cmd2 app command
+    """Encapsulates the results from a cmd2 app command.
 
     :stdout: str - output captured from stdout while this command is executing
     :stderr: str - output captured from stderr while this command is executing
@@ -71,20 +69,17 @@ class CommandResult(NamedTuple):
     data: Any = None
 
     def __bool__(self) -> bool:
-        """Returns True if the command succeeded, otherwise False"""
-
+        """Return True if the command succeeded, otherwise False."""
         # If data was set, then use it to determine success
         if self.data is not None:
             return bool(self.data)
 
         # Otherwise check if stderr was filled out
-        else:
-            return not self.stderr
+        return not self.stderr
 
 
 class PyBridge:
-    """
-    Provides a Python API wrapper for application commands.
+    """Provides a Python API wrapper for application commands.
 
     :param cmd2_app: app being controlled by this PyBridge.
     :param add_to_history: If True, then add all commands run by this PyBridge to history.
@@ -92,6 +87,7 @@ class PyBridge:
     """
 
     def __init__(self, cmd2_app: 'cmd2.Cmd', *, add_to_history: bool = True) -> None:
+        """Initialize PyBridge instances."""
         self._cmd2_app = cmd2_app
         self._add_to_history = add_to_history
         self.cmd_echo = False
@@ -99,15 +95,15 @@ class PyBridge:
         # Tells if any of the commands run via __call__ returned True for stop
         self.stop = False
 
-    def __dir__(self) -> List[str]:
-        """Return a custom set of attribute names"""
-        attributes: List[str] = []
+    def __dir__(self) -> list[str]:
+        """Return a custom set of attribute names."""
+        attributes: list[str] = []
         attributes.insert(0, 'cmd_echo')
         return attributes
 
     def __call__(self, command: str, *, echo: Optional[bool] = None) -> CommandResult:
-        """
-        Provide functionality to call application commands by calling PyBridge
+        """Provide functionality to call application commands by calling PyBridge.
+
         ex: app('help')
         :param command: command line being run
         :param echo: If provided, this temporarily overrides the value of self.cmd_echo while the
@@ -131,23 +127,21 @@ class PyBridge:
         stop = False
         try:
             self._cmd2_app.stdout = cast(TextIO, copy_cmd_stdout)
-            with redirect_stdout(cast(IO[str], copy_cmd_stdout)):
-                with redirect_stderr(cast(IO[str], copy_stderr)):
-                    stop = self._cmd2_app.onecmd_plus_hooks(
-                        command,
-                        add_to_history=self._add_to_history,
-                        py_bridge_call=True,
-                    )
+            with redirect_stdout(cast(IO[str], copy_cmd_stdout)), redirect_stderr(cast(IO[str], copy_stderr)):
+                stop = self._cmd2_app.onecmd_plus_hooks(
+                    command,
+                    add_to_history=self._add_to_history,
+                    py_bridge_call=True,
+                )
         finally:
             with self._cmd2_app.sigint_protection:
                 self._cmd2_app.stdout = cast(IO[str], copy_cmd_stdout.inner_stream)
                 self.stop = stop or self.stop
 
         # Save the result
-        result = CommandResult(
+        return CommandResult(
             stdout=copy_cmd_stdout.getvalue(),
             stderr=copy_stderr.getvalue(),
             stop=stop,
             data=self._cmd2_app.last_result,
         )
-        return result

cmd2/rl_utils.py

@@ -1,15 +1,11 @@
-# coding=utf-8
-"""
-Imports the proper Readline for the platform and provides utility functions for it
-"""
+"""Imports the proper Readline for the platform and provides utility functions for it."""
 
+import contextlib
 import sys
 from enum import (
     Enum,
 )
-from typing import (
-    Union,
-)
+from typing import Union
 
 #########################################################################################################################
 # NOTE ON LIBEDIT:
@@ -32,14 +28,12 @@ try:
     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:
+    with contextlib.suppress(ImportError):
         import readline  # type: ignore[no-redef]
-    except ImportError:  # pragma: no cover
-        pass
 
 
 class RlType(Enum):
-    """Readline library types we support"""
+    """Readline library types we support."""
 
     GNU = 1
     PYREADLINE = 2
@@ -72,30 +66,30 @@ if 'pyreadline3' in sys.modules:
     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
+            """Enable VT100 character sequences in a Windows console.
+
             This only works on Windows 10 and up
             :param handle: the handle on which to enable vt100
-            :return: True if vt100 characters are enabled for the handle
+            :return: True if vt100 characters are enabled for the handle.
             """
-            ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+            enable_virtual_terminal_processing = 0x0004
 
             # Get the current mode for this handle in the console
             cur_mode = DWORD(0)
             readline.rl.console.GetConsoleMode(handle, byref(cur_mode))
 
-            retVal = False
+            ret_val = False
 
             # Check if ENABLE_VIRTUAL_TERMINAL_PROCESSING is already enabled
-            if (cur_mode.value & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0:
-                retVal = True
+            if (cur_mode.value & enable_virtual_terminal_processing) != 0:
+                ret_val = True
 
-            elif readline.rl.console.SetConsoleMode(handle, cur_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING):
+            elif readline.rl.console.SetConsoleMode(handle, cur_mode.value | enable_virtual_terminal_processing):
                 # Restore the original mode when we exit
                 atexit.register(readline.rl.console.SetConsoleMode, handle, cur_mode)
-                retVal = True
+                ret_val = True
 
-            return retVal
+            return ret_val
 
         # Enable VT100 sequences for stdout and stderr
         STD_OUT_HANDLE = -11
@@ -107,15 +101,15 @@ if 'pyreadline3' in sys.modules:
     ############################################################################################################
     # pyreadline3 is incomplete in terms of the Python readline API. Add the missing functions we need.
     ############################################################################################################
-    # readline.remove_history_item()
-    try:
-        getattr(readline, 'remove_history_item')
-    except AttributeError:
+    # Add missing `readline.remove_history_item()`
+    if not hasattr(readline, 'remove_history_item'):
 
         def pyreadline_remove_history_item(pos: int) -> None:
-            """
-            An implementation of remove_history_item() for pyreadline3
-            :param pos: The 0-based position in history to remove
+            """Remove the specified item number from the pyreadline3 history.
+
+            An implementation of remove_history_item() for pyreadline3.
+
+            :param pos: The 0-based position in history to remove.
             """
             # Save of the current location of the history cursor
             saved_cursor = readline.rl.mode._history.history_cursor
@@ -159,10 +153,9 @@ else:
 
 
 def rl_force_redisplay() -> None:  # pragma: no cover
-    """
-    Causes readline to display the prompt and input text wherever the cursor is and start
-    reading input from this location. This is the proper way to restore the input line after
-    printing to the screen
+    """Causes readline to display the prompt and input text wherever the cursor is and start reading input from this location.
+
+    This is the proper way to restore the input line after printing to the screen.
     """
     if not sys.stdout.isatty():
         return
@@ -181,34 +174,25 @@ def rl_force_redisplay() -> None:  # pragma: no cover
 
 
 def rl_get_point() -> int:  # pragma: no cover
-    """
-    Returns the offset of the current cursor position in rl_line_buffer
-    """
+    """Return the offset of the current cursor position in rl_line_buffer."""
     if rl_type == RlType.GNU:
         return ctypes.c_int.in_dll(readline_lib, "rl_point").value
 
-    elif rl_type == RlType.PYREADLINE:
+    if rl_type == RlType.PYREADLINE:
         return int(readline.rl.mode.l_buffer.point)
 
-    else:
-        return 0
+    return 0
 
 
 def rl_get_prompt() -> str:  # pragma: no cover
-    """Get Readline's 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:
-            prompt = ''
-        else:
-            prompt = encoded_prompt.decode(encoding='utf-8')
+        prompt = '' if encoded_prompt is None else encoded_prompt.decode(encoding='utf-8')
 
     elif rl_type == RlType.PYREADLINE:
         prompt_data: Union[str, bytes] = readline.rl.prompt
-        if isinstance(prompt_data, bytes):
-            prompt = prompt_data.decode(encoding='utf-8')
-        else:
-            prompt = prompt_data
+        prompt = prompt_data.decode(encoding='utf-8') if isinstance(prompt_data, bytes) else prompt_data
 
     else:
         prompt = ''
@@ -217,27 +201,22 @@ def rl_get_prompt() -> str:  # pragma: no cover
 
 
 def rl_get_display_prompt() -> str:  # pragma: no cover
-    """
-    Get Readline's currently displayed prompt.
+    """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')
+        prompt = '' if encoded_prompt is None else encoded_prompt.decode(encoding='utf-8')
         return rl_unescape_prompt(prompt)
-    else:
-        return rl_get_prompt()
+    return rl_get_prompt()
 
 
 def rl_set_prompt(prompt: str) -> None:  # pragma: no cover
-    """
-    Sets Readline's prompt
-    :param prompt: the new prompt value
+    """Set Readline's prompt.
+
+    :param prompt: the new prompt value.
     """
     escaped_prompt = rl_escape_prompt(prompt)
 
@@ -250,8 +229,7 @@ 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
@@ -278,12 +256,11 @@ def rl_escape_prompt(prompt: str) -> str:
 
         return result
 
-    else:
-        return prompt
+    return prompt
 
 
 def rl_unescape_prompt(prompt: str) -> str:
-    """Remove escape characters from a Readline prompt"""
+    """Remove escape characters from a Readline prompt."""
     if rl_type == RlType.GNU:
         escape_start = "\x01"
         escape_end = "\x02"
@@ -293,16 +270,16 @@ def rl_unescape_prompt(prompt: str) -> str:
 
 
 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"""
+    """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
+        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:
+        return bool(in_search_mode & readline_state)
+    if rl_type == RlType.PYREADLINE:
         from pyreadline3.modes.emacs import (  # type: ignore[import]
             EmacsMode,
         )
@@ -317,5 +294,4 @@ def rl_in_search_mode() -> bool:  # pragma: no cover
             readline.rl.mode._process_non_incremental_search_keyevent,
         )
         return readline.rl.mode.process_keyevent_queue[-1] in search_funcs
-    else:
-        return False
+    return False