| | """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 |
| |
|
