|
|
"""Contains the interface class :class:`.BaseComplexPrompt` for more complex prompts and the mocked document class :class:`.FakeDocument`.""" |
|
|
import shutil |
|
|
from dataclasses import dataclass |
|
|
from typing import Any, Callable, List, Optional, Tuple, Union |
|
|
|
|
|
from prompt_toolkit.application import Application |
|
|
from prompt_toolkit.enums import EditingMode |
|
|
from prompt_toolkit.filters.base import Condition, FilterOrBool |
|
|
from prompt_toolkit.key_binding.key_bindings import KeyHandlerCallable |
|
|
from prompt_toolkit.keys import Keys |
|
|
|
|
|
from InquirerPy.base.simple import BaseSimplePrompt |
|
|
from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT |
|
|
from InquirerPy.utils import ( |
|
|
InquirerPySessionResult, |
|
|
InquirerPyStyle, |
|
|
InquirerPyValidate, |
|
|
) |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class FakeDocument: |
|
|
"""A fake `prompt_toolkit` document class. |
|
|
|
|
|
Work around to allow non-buffer type :class:`~prompt_toolkit.layout.UIControl` to use |
|
|
:class:`~prompt_toolkit.validation.Validator`. |
|
|
|
|
|
Args: |
|
|
text: Content to be validated. |
|
|
cursor_position: Fake cursor position. |
|
|
""" |
|
|
|
|
|
text: str |
|
|
cursor_position: int = 0 |
|
|
|
|
|
|
|
|
class BaseComplexPrompt(BaseSimplePrompt): |
|
|
"""A base class to create a more complex prompt that will involve :class:`~prompt_toolkit.application.Application`. |
|
|
|
|
|
Note: |
|
|
This class does not create :class:`~prompt_toolkit.layout.Layout` nor :class:`~prompt_toolkit.application.Application`, |
|
|
it only contains the necessary attributes and helper functions to be consumed. |
|
|
|
|
|
Note: |
|
|
Use :class:`~InquirerPy.base.BaseListPrompt` to create a complex list prompt which involves multiple choices. It has |
|
|
more methods and helper function implemented. |
|
|
|
|
|
See Also: |
|
|
:class:`~InquirerPy.base.BaseListPrompt` |
|
|
:class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt` |
|
|
""" |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
message: Union[str, Callable[[InquirerPySessionResult], str]], |
|
|
style: Optional[InquirerPyStyle] = None, |
|
|
border: bool = False, |
|
|
vi_mode: bool = False, |
|
|
qmark: str = "?", |
|
|
amark: str = "?", |
|
|
instruction: str = "", |
|
|
long_instruction: str = "", |
|
|
transformer: Optional[Callable[[Any], Any]] = None, |
|
|
filter: Optional[Callable[[Any], Any]] = None, |
|
|
validate: Optional[InquirerPyValidate] = None, |
|
|
invalid_message: str = "Invalid input", |
|
|
wrap_lines: bool = True, |
|
|
raise_keyboard_interrupt: bool = True, |
|
|
mandatory: bool = True, |
|
|
mandatory_message: str = "Mandatory prompt", |
|
|
session_result: Optional[InquirerPySessionResult] = None, |
|
|
) -> None: |
|
|
super().__init__( |
|
|
message=message, |
|
|
style=style, |
|
|
vi_mode=vi_mode, |
|
|
qmark=qmark, |
|
|
amark=amark, |
|
|
instruction=instruction, |
|
|
transformer=transformer, |
|
|
filter=filter, |
|
|
invalid_message=invalid_message, |
|
|
validate=validate, |
|
|
wrap_lines=wrap_lines, |
|
|
raise_keyboard_interrupt=raise_keyboard_interrupt, |
|
|
mandatory=mandatory, |
|
|
mandatory_message=mandatory_message, |
|
|
session_result=session_result, |
|
|
) |
|
|
self._invalid_message = invalid_message |
|
|
self._rendered = False |
|
|
self._invalid = False |
|
|
self._loading = False |
|
|
self._application: Application |
|
|
self._long_instruction = long_instruction |
|
|
self._border = border |
|
|
self._height_offset = 2 |
|
|
if self._border: |
|
|
self._height_offset += 2 |
|
|
if self._long_instruction: |
|
|
self._height_offset += 1 |
|
|
self._validation_window_bottom_offset = 0 if not self._long_instruction else 1 |
|
|
if self._wrap_lines: |
|
|
self._validation_window_bottom_offset += ( |
|
|
self.extra_long_instruction_line_count |
|
|
) |
|
|
|
|
|
self._is_vim_edit = Condition(lambda: self._editing_mode == EditingMode.VI) |
|
|
self._is_invalid = Condition(lambda: self._invalid) |
|
|
self._is_displaying_long_instruction = Condition( |
|
|
lambda: self._long_instruction != "" |
|
|
) |
|
|
|
|
|
def _redraw(self) -> None: |
|
|
"""Redraw the application UI.""" |
|
|
self._application.invalidate() |
|
|
|
|
|
def register_kb( |
|
|
self, *keys: Union[Keys, str], filter: FilterOrBool = True |
|
|
) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]: |
|
|
"""Decorate keybinding registration function. |
|
|
|
|
|
Ensure that the `invalid` state is cleared on next keybinding entered. |
|
|
""" |
|
|
kb_dec = super().register_kb(*keys, filter=filter) |
|
|
|
|
|
def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable: |
|
|
@kb_dec |
|
|
def executable(event): |
|
|
if self._invalid: |
|
|
self._invalid = False |
|
|
func(event) |
|
|
|
|
|
return executable |
|
|
|
|
|
return decorator |
|
|
|
|
|
def _exception_handler(self, _, context) -> None: |
|
|
"""Set exception handler for the event loop. |
|
|
|
|
|
Skip the question and raise exception. |
|
|
|
|
|
Args: |
|
|
loop: Current event loop. |
|
|
context: Exception context. |
|
|
""" |
|
|
self._status["answered"] = True |
|
|
self._status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT |
|
|
self._status["skipped"] = True |
|
|
self._application.exit(exception=context["exception"]) |
|
|
|
|
|
def _after_render(self, app: Optional[Application]) -> None: |
|
|
"""Run after the :class:`~prompt_toolkit.application.Application` is rendered/updated. |
|
|
|
|
|
Since this function is fired up on each render, adding a check on `self._rendered` to |
|
|
process logics that should only run once. |
|
|
|
|
|
Set event loop exception handler here, since its guaranteed that the event loop is running |
|
|
in `_after_render`. |
|
|
""" |
|
|
if not self._rendered: |
|
|
self._rendered = True |
|
|
|
|
|
self._keybinding_factory() |
|
|
self._on_rendered(app) |
|
|
|
|
|
def _set_error(self, message: str) -> None: |
|
|
"""Set error message and set invalid state. |
|
|
|
|
|
Args: |
|
|
message: Error message to display. |
|
|
""" |
|
|
self._invalid_message = message |
|
|
self._invalid = True |
|
|
|
|
|
def _get_error_message(self) -> List[Tuple[str, str]]: |
|
|
"""Obtain the error message dynamically. |
|
|
|
|
|
Returns: |
|
|
FormattedText in list of tuple format. |
|
|
""" |
|
|
return [ |
|
|
( |
|
|
"class:validation-toolbar", |
|
|
self._invalid_message, |
|
|
) |
|
|
] |
|
|
|
|
|
def _on_rendered(self, _: Optional[Application]) -> None: |
|
|
"""Run once after the UI is rendered. Acts like `ComponentDidMount`.""" |
|
|
pass |
|
|
|
|
|
def _get_prompt_message(self) -> List[Tuple[str, str]]: |
|
|
"""Get the prompt message to display. |
|
|
|
|
|
Returns: |
|
|
Formatted text in list of tuple format. |
|
|
""" |
|
|
pre_answer = ( |
|
|
"class:instruction", |
|
|
" %s " % self.instruction if self.instruction else " ", |
|
|
) |
|
|
post_answer = ("class:answer", " %s" % self.status["result"]) |
|
|
return super()._get_prompt_message(pre_answer, post_answer) |
|
|
|
|
|
def _run(self) -> Any: |
|
|
"""Run the application.""" |
|
|
return self.application.run() |
|
|
|
|
|
async def _run_async(self) -> None: |
|
|
"""Run the application asynchronously.""" |
|
|
return await self.application.run_async() |
|
|
|
|
|
@property |
|
|
def application(self) -> Application: |
|
|
"""Get the application. |
|
|
|
|
|
:class:`.BaseComplexPrompt` requires :attr:`.BaseComplexPrompt._application` to be defined since this class |
|
|
doesn't implement :class:`~prompt_toolkit.layout.Layout` and :class:`~prompt_toolkit.application.Application`. |
|
|
|
|
|
Raises: |
|
|
NotImplementedError: When `self._application` is not defined. |
|
|
""" |
|
|
if not self._application: |
|
|
raise NotImplementedError |
|
|
return self._application |
|
|
|
|
|
@application.setter |
|
|
def application(self, value: Application) -> None: |
|
|
self._application = value |
|
|
|
|
|
@property |
|
|
def height_offset(self) -> int: |
|
|
"""int: Height offset to apply.""" |
|
|
if not self._wrap_lines: |
|
|
return self._height_offset |
|
|
return self.extra_line_count + self._height_offset |
|
|
|
|
|
@property |
|
|
def total_message_length(self) -> int: |
|
|
"""int: Total length of the message.""" |
|
|
total_message_length = 0 |
|
|
if self._qmark: |
|
|
total_message_length += len(self._qmark) |
|
|
total_message_length += 1 |
|
|
total_message_length += len(str(self._message)) |
|
|
total_message_length += 1 |
|
|
total_message_length += len(str(self._instruction)) |
|
|
if self._instruction: |
|
|
total_message_length += 1 |
|
|
return total_message_length |
|
|
|
|
|
@property |
|
|
def extra_message_line_count(self) -> int: |
|
|
"""int: Get the extra lines created caused by line wrapping. |
|
|
|
|
|
Minus 1 on the totoal message length as we only want the extra line. |
|
|
24 // 24 will equal to 1 however we only want the value to be 1 when we have 25 char |
|
|
which will create an extra line. |
|
|
""" |
|
|
term_width, _ = shutil.get_terminal_size() |
|
|
return (self.total_message_length - 1) // term_width |
|
|
|
|
|
@property |
|
|
def extra_long_instruction_line_count(self) -> int: |
|
|
"""int: Get the extra lines created caused by line wrapping. |
|
|
|
|
|
See Also: |
|
|
:attr:`.BaseComplexPrompt.extra_message_line_count` |
|
|
""" |
|
|
if self._long_instruction: |
|
|
term_width, _ = shutil.get_terminal_size() |
|
|
return (len(self._long_instruction) - 1) // term_width |
|
|
else: |
|
|
return 0 |
|
|
|
|
|
@property |
|
|
def extra_line_count(self) -> int: |
|
|
"""Get the extra lines created caused by line wrapping. |
|
|
|
|
|
Used mainly to calculate how much additional offset should be applied when getting |
|
|
the height. |
|
|
|
|
|
Returns: |
|
|
Total extra lines created due to line wrapping. |
|
|
""" |
|
|
result = 0 |
|
|
|
|
|
|
|
|
result += self.extra_message_line_count |
|
|
|
|
|
result += self.extra_long_instruction_line_count |
|
|
|
|
|
return result |
|
|
|
