Upload folder using huggingface_hub

.env/lib/python3.12/site-packages/InquirerPy/__init__.py

@@ -0,0 +1,2 @@
+from InquirerPy.resolver import prompt, prompt_async
+from InquirerPy.utils import get_style

.env/lib/python3.12/site-packages/InquirerPy/base/__init__.py

@@ -0,0 +1,15 @@
+"""Module contains base class for prompts.
+
+BaseSimplePrompt ← InputPrompt ← SecretPrompt ...
+        ↑
+BaseComplexPrompt
+        ↑
+BaseListPrompt ← FuzzyPrompt
+        ↑
+ListPrompt ← ExpandPrompt ...
+"""
+
+from .complex import BaseComplexPrompt, FakeDocument
+from .control import Choice, InquirerPyUIListControl
+from .list import BaseListPrompt
+from .simple import BaseSimplePrompt

.env/lib/python3.12/site-packages/InquirerPy/base/complex.py

@@ -0,0 +1,294 @@
+"""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  # prev prompt result + current prompt question
+        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  # Extra space if qmark is present
+        total_message_length += len(str(self._message))
+        total_message_length += 1  # Extra space between message and instruction
+        total_message_length += len(str(self._instruction))
+        if self._instruction:
+            total_message_length += 1  # Extra space behind the instruction
+        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
+
+        # message wrap
+        result += self.extra_message_line_count
+        # long instruction wrap
+        result += self.extra_long_instruction_line_count
+
+        return result

.env/lib/python3.12/site-packages/InquirerPy/base/control.py

@@ -0,0 +1,227 @@
+"""Contains the content control class :class:`.InquirerPyUIListControl`."""
+from abc import abstractmethod
+from dataclasses import asdict, dataclass
+from typing import Any, Callable, Dict, List, Optional, Tuple, cast
+
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from InquirerPy.exceptions import InvalidArgument, RequiredKeyNotFound
+from InquirerPy.separator import Separator
+from InquirerPy.utils import InquirerPyListChoices, InquirerPySessionResult
+
+__all__ = ["Choice", "InquirerPyUIListControl"]
+
+
+@dataclass
+class Choice:
+    """Class to create choices for list type prompts.
+
+    A simple dataclass that can be used as an alternate to using :class:`dict`
+    when working with choices.
+
+    Args:
+        value: The value of the choice when user selects this choice.
+        name: The value that should be presented to the user prior/after selection of the choice.
+            This value is optional, if not provided, it will fallback to the string representation of `value`.
+        enabled: Indicates if the choice should be pre-selected.
+            This only has effects when the prompt has `multiselect` enabled.
+    """
+
+    value: Any
+    name: Optional[str] = None
+    enabled: bool = False
+
+    def __post_init__(self):
+        """Assign strinify value to name if not present."""
+        if self.name is None:
+            self.name = str(self.value)
+
+
+class InquirerPyUIListControl(FormattedTextControl):
+    """A base class to create :class:`~prompt_toolkit.layout.UIControl` to display list type contents.
+
+    Args:
+        choices(InquirerPyListChoices): List of choices to display as the content.
+            Can also be a callable or async callable that returns a list of choices.
+        default: Default value, this will affect the cursor position.
+        multiselect: Indicate if the current prompt has `multiselect` enabled.
+        session_result: Current session result.
+    """
+
+    def __init__(
+        self,
+        choices: InquirerPyListChoices,
+        default: Any = None,
+        multiselect: bool = False,
+        session_result: Optional[InquirerPySessionResult] = None,
+    ) -> None:
+        self._session_result = session_result or {}
+        self._selected_choice_index: int = 0
+        self._choice_func = None
+        self._multiselect = multiselect
+        self._default = (
+            default
+            if not isinstance(default, Callable)
+            else cast(Callable, default)(self._session_result)
+        )
+        self._raw_choices = (
+            choices
+            if not isinstance(choices, Callable)
+            else cast(Callable, choices)(self._session_result)
+        )
+        self._choices = self._get_choices(self._raw_choices, self._default)
+        self._safety_check()
+        self._format_choices()
+        super().__init__(self._get_formatted_choices)
+
+    def _get_choices(self, choices: List[Any], default: Any) -> List[Dict[str, Any]]:
+        """Process the raw user input choices and format it into dictionary.
+
+        Args:
+            choices: List of chices to display.
+            default: Default value, this will affect the :attr:`.InquirerPyUIListControl.selected_choice_index`
+
+        Returns:
+            List of choices.
+
+        Raises:
+            RequiredKeyNotFound: When the provided choice is missing the `name` or `value` key.
+        """
+        processed_choices: List[Dict[str, Any]] = []
+        try:
+            for index, choice in enumerate(choices, start=0):
+                if isinstance(choice, dict):
+                    if choice["value"] == default:
+                        self.selected_choice_index = index
+                    processed_choices.append(
+                        {
+                            "name": str(choice["name"]),
+                            "value": choice["value"],
+                            "enabled": choice.get("enabled", False)
+                            if self._multiselect
+                            else False,
+                        }
+                    )
+                elif isinstance(choice, Separator):
+                    if self.selected_choice_index == index:
+                        self.selected_choice_index = (
+                            self.selected_choice_index + 1
+                        ) % len(choices)
+                    processed_choices.append(
+                        {"name": str(choice), "value": choice, "enabled": False}
+                    )
+                elif isinstance(choice, Choice):
+                    dict_choice = asdict(choice)
+                    if dict_choice["value"] == default:
+                        self.selected_choice_index = index
+                    if not self._multiselect:
+                        dict_choice["enabled"] = False
+                    processed_choices.append(dict_choice)
+                else:
+                    if choice == default:
+                        self.selected_choice_index = index
+                    processed_choices.append(
+                        {"name": str(choice), "value": choice, "enabled": False}
+                    )
+        except KeyError:
+            raise RequiredKeyNotFound(
+                "dictionary type of choice require a 'name' key and a 'value' key"
+            )
+        return processed_choices
+
+    @property
+    def selected_choice_index(self) -> int:
+        """int: Current highlighted index."""
+        return self._selected_choice_index
+
+    @selected_choice_index.setter
+    def selected_choice_index(self, value: int) -> None:
+        self._selected_choice_index = value
+
+    @property
+    def choices(self) -> List[Dict[str, Any]]:
+        """List[Dict[str, Any]]: Get all processed choices."""
+        return self._choices
+
+    @choices.setter
+    def choices(self, value: List[Dict[str, Any]]) -> None:
+        self._choices = value
+
+    def _safety_check(self) -> None:
+        """Validate processed choices.
+
+        Check if the choices are empty or if it only contains :class:`~InquirerPy.separator.Separator`.
+        """
+        if not self.choices:
+            raise InvalidArgument("argument choices cannot be empty")
+        should_proceed: bool = False
+        for choice in self.choices:
+            if not isinstance(choice["value"], Separator):
+                should_proceed = True
+                break
+        if not should_proceed:
+            raise InvalidArgument(
+                "argument choices should contain choices other than separator"
+            )
+
+    def _get_formatted_choices(self) -> List[Tuple[str, str]]:
+        """Get all choices in formatted text format.
+
+        Returns:
+            List of choices in formatted text form.
+        """
+        display_choices = []
+
+        for index, choice in enumerate(self.choices):
+            if index == self.selected_choice_index:
+                display_choices += self._get_hover_text(choice)
+            else:
+                display_choices += self._get_normal_text(choice)
+            display_choices.append(("", "\n"))
+        if display_choices:
+            display_choices.pop()
+        return display_choices
+
+    def _format_choices(self) -> None:
+        """Perform post processing on the choices.
+
+        Additional customisation to the choices after :meth:`.InquirerPyUIListControl._get_choices` call.
+        """
+        pass
+
+    @abstractmethod
+    def _get_hover_text(self, choice) -> List[Tuple[str, str]]:
+        """Generate the formatted text for hovered choice.
+
+        Returns:
+            Formatted text in list of tuple format.
+        """
+        pass
+
+    @abstractmethod
+    def _get_normal_text(self, choice) -> List[Tuple[str, str]]:
+        """Generate the formatted text for non-hovered choices.
+
+        Returns:
+            Formatted text in list of tuple format.
+        """
+        pass
+
+    @property
+    def choice_count(self) -> int:
+        """int: Total count of choices."""
+        return len(self.choices)
+
+    @property
+    def selection(self) -> Dict[str, Any]:
+        """Dict[str, Any]: Current selected choice."""
+        return self.choices[self.selected_choice_index]
+
+    @property
+    def loading(self) -> bool:
+        """bool: Indicate if the content control is loading."""
+        return self._loading
+
+    @loading.setter
+    def loading(self, value: bool) -> None:
+        self._loading = value

.env/lib/python3.12/site-packages/InquirerPy/base/list.py

@@ -0,0 +1,238 @@
+"""Contains the base class :class:`.BaseListPrompt` which can be used to create a prompt involving choices."""
+from abc import abstractmethod
+from typing import Any, Callable, List, Optional
+
+from prompt_toolkit.filters.base import Condition
+from prompt_toolkit.keys import Keys
+
+from InquirerPy.base.complex import BaseComplexPrompt
+from InquirerPy.base.control import InquirerPyUIListControl
+from InquirerPy.separator import Separator
+from InquirerPy.utils import (
+    InquirerPyKeybindings,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+
+class BaseListPrompt(BaseComplexPrompt):
+    """A base class to create a complex prompt involving choice selections (i.e. list) using `prompt_toolkit` 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.
+
+    See Also:
+        :class:`~InquirerPy.prompts.list.ListPrompt`
+        :class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt`
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        long_instruction: str = "",
+        border: bool = False,
+        transformer: Optional[Callable[[Any], Any]] = None,
+        filter: Optional[Callable[[Any], Any]] = None,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        multiselect: bool = False,
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        cycle: bool = True,
+        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,
+            border=border,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            transformer=transformer,
+            filter=filter,
+            invalid_message=invalid_message,
+            validate=validate,
+            instruction=instruction,
+            long_instruction=long_instruction,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+        )
+
+        self._content_control: InquirerPyUIListControl
+        self._multiselect = multiselect
+        self._is_multiselect = Condition(lambda: self._multiselect)
+        self._cycle = cycle
+
+        if not keybindings:
+            keybindings = {}
+
+        self.kb_maps = {
+            "down": [
+                {"key": "down"},
+                {"key": "c-n", "filter": ~self._is_vim_edit},
+                {"key": "j", "filter": self._is_vim_edit},
+            ],
+            "up": [
+                {"key": "up"},
+                {"key": "c-p", "filter": ~self._is_vim_edit},
+                {"key": "k", "filter": self._is_vim_edit},
+            ],
+            "toggle": [
+                {"key": "space"},
+            ],
+            "toggle-down": [
+                {"key": Keys.Tab},
+            ],
+            "toggle-up": [
+                {"key": Keys.BackTab},
+            ],
+            "toggle-all": [
+                {"key": "alt-r"},
+                {"key": "c-r"},
+            ],
+            "toggle-all-true": [
+                {"key": "alt-a"},
+                {"key": "c-a"},
+            ],
+            "toggle-all-false": [],
+            **keybindings,
+        }
+
+        self.kb_func_lookup = {
+            "down": [{"func": self._handle_down}],
+            "up": [{"func": self._handle_up}],
+            "toggle": [{"func": self._handle_toggle_choice}],
+            "toggle-down": [
+                {"func": self._handle_toggle_choice},
+                {"func": self._handle_down},
+            ],
+            "toggle-up": [
+                {"func": self._handle_toggle_choice},
+                {"func": self._handle_up},
+            ],
+            "toggle-all": [{"func": self._handle_toggle_all}],
+            "toggle-all-true": [{"func": self._handle_toggle_all, "args": [True]}],
+            "toggle-all-false": [{"func": self._handle_toggle_all, "args": [False]}],
+        }
+
+    @property
+    def content_control(self) -> InquirerPyUIListControl:
+        """Get the content controller object.
+
+        Needs to be an instance of :class:`~InquirerPy.base.control.InquirerPyUIListControl`.
+
+        Each :class:`.BaseComplexPrompt` requires a `content_control` to display custom
+        contents for the prompt.
+
+        Raises:
+            NotImplementedError: When `self._content_control` is not found.
+        """
+        if not self._content_control:
+            raise NotImplementedError
+        return self._content_control
+
+    @content_control.setter
+    def content_control(self, value: InquirerPyUIListControl) -> None:
+        self._content_control = value
+
+    @property
+    def result_name(self) -> Any:
+        """Get the result value that should be printed to the terminal.
+
+        In multiselect scenario, return result as a list.
+        """
+        if self._multiselect:
+            return [choice["name"] for choice in self.selected_choices]
+        else:
+            try:
+                return self.content_control.selection["name"]
+            except IndexError:
+                return ""
+
+    @property
+    def result_value(self) -> Any:
+        """Get the result value that should return to the user.
+
+        In multiselect scenario, return result as a list.
+        """
+        if self._multiselect:
+            return [choice["value"] for choice in self.selected_choices]
+        else:
+            try:
+                return self.content_control.selection["value"]
+            except IndexError:
+                return ""
+
+    @property
+    def selected_choices(self) -> List[Any]:
+        """List[Any]: Get all user selected choices."""
+
+        def filter_choice(choice):
+            return not isinstance(choice, Separator) and choice["enabled"]
+
+        return list(filter(filter_choice, self.content_control.choices))
+
+    def _handle_down(self, _) -> bool:
+        """Handle event when user attempts to move down.
+
+        Returns:
+            Boolean indicating if the action hits the cap.
+        """
+        if self._cycle:
+            self.content_control.selected_choice_index = (
+                self.content_control.selected_choice_index + 1
+            ) % self.content_control.choice_count
+            return False
+        else:
+            self.content_control.selected_choice_index += 1
+            if (
+                self.content_control.selected_choice_index
+                >= self.content_control.choice_count
+            ):
+                self.content_control.selected_choice_index = (
+                    self.content_control.choice_count - 1
+                )
+                return True
+            return False
+
+    def _handle_up(self, _) -> bool:
+        """Handle event when user attempts to move up.
+
+        Returns:
+            Boolean indicating if the action hits the cap.
+        """
+        if self._cycle:
+            self.content_control.selected_choice_index = (
+                self.content_control.selected_choice_index - 1
+            ) % self.content_control.choice_count
+            return False
+        else:
+            self.content_control.selected_choice_index -= 1
+            if self.content_control.selected_choice_index < 0:
+                self.content_control.selected_choice_index = 0
+                return True
+            return False
+
+    @abstractmethod
+    def _handle_toggle_choice(self, event) -> None:
+        """Handle event when user attempting to toggle the state of the chocie."""
+        pass
+
+    @abstractmethod
+    def _handle_toggle_all(self, event, value: bool) -> None:
+        """Handle event when user attempting to alter the state of all choices."""
+        pass

.env/lib/python3.12/site-packages/InquirerPy/base/simple.py

@@ -0,0 +1,378 @@
+"""Contains the base class :class:`.BaseSimplePrompt`."""
+import os
+import re
+from abc import ABC, abstractmethod
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.filters.base import Condition, FilterOrBool
+from prompt_toolkit.key_binding.key_bindings import KeyBindings, KeyHandlerCallable
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.styles.style import Style
+from prompt_toolkit.validation import Validator
+
+from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT
+from InquirerPy.exceptions import RequiredKeyNotFound
+from InquirerPy.utils import (
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+    get_style,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+
+class BaseSimplePrompt(ABC):
+    """The base class to create a simple terminal input prompt.
+
+    Note:
+        No actual :class:`~prompt_toolkit.application.Application` is created by this class.
+        This class only creates some common interface and attributes that can be easily used
+        by `prompt_toolkit`.
+
+        To have a functional prompt, you'll at least have to implement the :meth:`.BaseSimplePrompt._run`
+        and :meth:`.BaseSimplePrompt._get_prompt_message`.
+
+    See Also:
+        :class:`~InquirerPy.prompts.input.InputPrompt`
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        transformer: Optional[Callable[[Any], Any]] = None,
+        filter: Optional[Callable[[Any], Any]] = None,
+        default: Any = "",
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+    ) -> None:
+        self._mandatory = mandatory
+        self._mandatory_message = mandatory_message
+        self._result = session_result or {}
+        self._message = (
+            message
+            if not isinstance(message, Callable)
+            else cast(Callable, message)(self._result)
+        )
+        self._instruction = instruction
+        self._default = (
+            default if not isinstance(default, Callable) else default(self._result)
+        )
+        self._style = Style.from_dict(style.dict if style else get_style().dict)
+        self._qmark = qmark
+        self._amark = amark
+        self._status = {"answered": False, "result": None, "skipped": False}
+        self._kb = KeyBindings()
+        self._lexer = "class:input"
+        self._transformer = transformer
+        self._filter = filter
+        self._wrap_lines = wrap_lines
+        self._editing_mode = (
+            EditingMode.VI
+            if vi_mode or bool(os.getenv("INQUIRERPY_VI_MODE", False))
+            else EditingMode.EMACS
+        )
+        if isinstance(validate, Validator):
+            self._validator = validate
+        else:
+            self._validator = Validator.from_callable(
+                validate if validate else lambda _: True,
+                invalid_message,
+                move_cursor_to_end=True,
+            )
+        self._raise_kbi = not os.getenv(
+            "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt
+        )
+        self._is_rasing_kbi = Condition(lambda: self._raise_kbi)
+
+        self._kb_maps = {
+            "answer": [{"key": Keys.Enter}],
+            "interrupt": [
+                {"key": "c-c", "filter": self._is_rasing_kbi},
+                {"key": "c-d", "filter": ~self._is_rasing_kbi},
+            ],
+            "skip": [{"key": "c-z"}, {"key": "c-c", "filter": ~self._is_rasing_kbi}],
+        }
+        self._kb_func_lookup = {
+            "answer": [{"func": self._handle_enter}],
+            "interrupt": [{"func": self._handle_interrupt}],
+            "skip": [{"func": self._handle_skip}],
+        }
+
+    def _keybinding_factory(self):
+        """Register all keybindings in `self._kb_maps`.
+
+        It's required to call this function at the end of prompt constructor if
+        it inherits from :class:`~InquirerPy.base.simple.BaseSimplePrompt` or
+        :class:`~InquirerPy.base.complex.BaseComplexPrompt`.
+        """
+
+        def _factory(keys, filter, action):
+            if action not in self.kb_func_lookup:
+                raise RequiredKeyNotFound(f"keybinding action {action} not found")
+            if not isinstance(keys, list):
+                keys = [keys]
+
+            @self.register_kb(*keys, filter=filter)
+            def _(event):
+                for method in self.kb_func_lookup[action]:
+                    method["func"](event, *method.get("args", []))
+
+        for key, item in self.kb_maps.items():
+            if not isinstance(item, list):
+                item = [item]
+            for kb in item:
+                _factory(kb["key"], kb.get("filter", Condition(lambda: True)), key)
+
+    @abstractmethod
+    def _set_error(self, message: str) -> None:
+        """Set the error message for the prompt.
+
+        Args:
+            message: Error message to set.
+        """
+        pass
+
+    def _handle_skip(self, event: Optional["KeyPressEvent"]) -> None:
+        """Handle the event when attempting to skip a prompt.
+
+        Skip the prompt if the `_mandatory` field is False, otherwise
+        show an error message that the prompt cannot be skipped.
+        """
+        if not self._mandatory:
+            self.status["answered"] = True
+            self.status["skipped"] = True
+            self.status["result"] = None
+            if event:
+                event.app.exit(result=None)
+        else:
+            self._set_error(message=self._mandatory_message)
+
+    def _handle_interrupt(self, event: Optional["KeyPressEvent"]) -> None:
+        """Handle the event when a KeyboardInterrupt signal is sent."""
+        self.status["answered"] = True
+        self.status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT
+        self.status["skipped"] = True
+        if event:
+            event.app.exit(result=INQUIRERPY_KEYBOARD_INTERRUPT)
+
+    @abstractmethod
+    def _handle_enter(self, event: Optional["KeyPressEvent"]) -> None:
+        """Handle the event when user attempt to answer the question."""
+        pass
+
+    @property
+    def status(self) -> Dict[str, Any]:
+        """Dict[str, Any]: Get current prompt status.
+
+        The status contains 3 keys: "answered" and "result".
+            answered: If the current prompt is answered.
+            result: The result of the user answer.
+            skipped: If the prompt is skipped.
+        """
+        return self._status
+
+    @status.setter
+    def status(self, value) -> None:
+        self._status = value
+
+    def register_kb(
+        self, *keys: Union[Keys, str], filter: FilterOrBool = True, **kwargs
+    ) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]:
+        """Keybinding registration decorator.
+
+        This decorator wraps around the :meth:`prompt_toolkit.key_binding.KeyBindings.add` with
+        added feature to process `alt` realted keybindings.
+
+        By default, `prompt_toolkit` doesn't process `alt` related keybindings,
+        it requires `alt-ANY` to `escape` + `ANY`.
+
+        Args:
+            keys: The keys to bind that can trigger the function.
+            filter: :class:`~prompt_toolkit.filter.Condition` to indicate if this keybinding should be active.
+
+        Returns:
+            A decorator that should be applied to the function thats intended to be active when the keys
+            are pressed.
+
+        Examples:
+            >>> @self.register_kb("alt-j")
+            ... def test(event):
+            ...     pass
+        """
+        alt_pattern = re.compile(r"^alt-(.*)")
+
+        def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable:
+            formatted_keys = []
+            for key in keys:
+                match = alt_pattern.match(key)
+                if match:
+                    formatted_keys.append("escape")
+                    formatted_keys.append(match.group(1))
+                else:
+                    formatted_keys.append(key)
+
+            @self._kb.add(*formatted_keys, filter=filter, **kwargs)
+            def executable(event) -> None:
+                func(event)
+
+            return executable
+
+        return decorator
+
+    @abstractmethod
+    def _get_prompt_message(
+        self, pre_answer: Tuple[str, str], post_answer: Tuple[str, str]
+    ) -> List[Tuple[str, str]]:
+        """Get the question message in formatted text form to display in the prompt.
+
+        This function is mainly used to render the question message dynamically based
+        on the current status (answered or not answered) of the prompt.
+
+        Note:
+            The function requires implementation when inheriting :class:`.BaseSimplePrompt`.
+            You should call `super()._get_prompt_message(pre_answer, post_answer)` in
+            the implemented `_get_prompt_message`.
+
+        Args:
+            pre_answer: The message to display before the question is answered.
+            post_answer: The information to display after the question is answered.
+
+        Returns:
+            Formatted text in list of tuple format.
+        """
+        display_message = []
+        if self.status["skipped"]:
+            display_message.append(("class:skipped", self._qmark))
+            display_message.append(
+                ("class:skipped", "%s%s " % (" " if self._qmark else "", self._message))
+            )
+        elif self.status["answered"]:
+            display_message.append(("class:answermark", self._amark))
+            display_message.append(
+                (
+                    "class:answered_question",
+                    "%s%s" % (" " if self._amark else "", self._message),
+                )
+            )
+            display_message.append(
+                post_answer
+                if not self._transformer
+                else (
+                    "class:answer",
+                    " %s" % self._transformer(self.status["result"]),
+                )
+            )
+        else:
+            display_message.append(("class:questionmark", self._qmark))
+            display_message.append(
+                (
+                    "class:question",
+                    "%s%s" % (" " if self._qmark else "", self._message),
+                )
+            )
+            display_message.append(pre_answer)
+        return display_message
+
+    @abstractmethod
+    def _run(self) -> Any:
+        """Abstractmethod to enforce a run function is implemented.
+
+        All prompt instance requires a `_run` call to initialise and run an instance of
+        `PromptSession` or `Application`.
+        """
+        pass
+
+    @abstractmethod
+    async def _run_async(self) -> Any:
+        """Abstractmethod to enforce a run function is implemented.
+
+        All prompt instance requires a `_run_async` call to initialise and run an instance of
+        `PromptSession` or `Application`.
+        """
+        pass
+
+    def execute(self, raise_keyboard_interrupt: Optional[bool] = None) -> Any:
+        """Run the prompt and get the result.
+
+        Args:
+            raise_keyboard_interrupt: **Deprecated**. Set this parameter on the prompt initialisation instead.
+
+        Returns:
+            Value of the user answer. Types varies depending on the prompt.
+
+        Raises:
+            KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True.
+        """
+        result = self._run()
+        if raise_keyboard_interrupt is not None:
+            self._raise_kbi = not os.getenv(
+                "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt
+            )
+        if result == INQUIRERPY_KEYBOARD_INTERRUPT:
+            raise KeyboardInterrupt
+        if not self._filter:
+            return result
+        return self._filter(result)
+
+    async def execute_async(self) -> None:
+        """Run the prompt asynchronously and get the result.
+
+        Returns:
+            Value of the user answer. Types varies depending on the prompt.
+
+        Raises:
+            KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True.
+        """
+        result = await self._run_async()
+        if result == INQUIRERPY_KEYBOARD_INTERRUPT:
+            raise KeyboardInterrupt
+        if not self._filter:
+            return result
+        return self._filter(result)
+
+    @property
+    def instruction(self) -> str:
+        """str: Instruction to display next to question."""
+        return self._instruction
+
+    @property
+    def kb_maps(self) -> Dict[str, Any]:
+        """Dict[str, Any]: Keybinding mappings."""
+        return self._kb_maps
+
+    @kb_maps.setter
+    def kb_maps(self, value: Dict[str, Any]) -> None:
+        self._kb_maps = {**self._kb_maps, **value}
+
+    @property
+    def kb_func_lookup(self) -> Dict[str, Any]:
+        """Dict[str, Any]: Keybinding function lookup mappings.."""
+        return self._kb_func_lookup
+
+    @kb_func_lookup.setter
+    def kb_func_lookup(self, value: Dict[str, Any]) -> None:
+        self._kb_func_lookup = {**self._kb_func_lookup, **value}

.env/lib/python3.12/site-packages/InquirerPy/containers/__init__.py

@@ -0,0 +1 @@
+from .spinner import SpinnerWindow

.env/lib/python3.12/site-packages/InquirerPy/containers/instruction.py

@@ -0,0 +1,38 @@
+"""Module contains :class:`.InstructionWindow` which can be used to display long instructions."""
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.layout.containers import ConditionalContainer, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+if TYPE_CHECKING:
+    from prompt_toolkit.filters.base import FilterOrBool
+    from prompt_toolkit.formatted_text.base import AnyFormattedText
+
+
+class InstructionWindow(ConditionalContainer):
+    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays long instructions.
+
+    Args:
+        message: Long instructions to display.
+        filter: Condition to display the instruction window.
+    """
+
+    def __init__(self, message: str, filter: "FilterOrBool", **kwargs) -> None:
+        self._message = message
+        super().__init__(
+            Window(
+                FormattedTextControl(text=self._get_message),
+                dont_extend_height=True,
+                **kwargs
+            ),
+            filter=filter,
+        )
+
+    def _get_message(self) -> "AnyFormattedText":
+        """Get long instruction to display.
+
+        Returns:
+            FormattedText in list of tuple format.
+        """
+        return [("class:long_instruction", self._message)]

.env/lib/python3.12/site-packages/InquirerPy/containers/message.py

@@ -0,0 +1,42 @@
+"""Module contains the main message window :class:`~prompt_toolkit.container.Container`."""
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.layout.containers import ConditionalContainer, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.dimension import LayoutDimension
+
+if TYPE_CHECKING:
+    from prompt_toolkit.filters.base import FilterOrBool
+    from prompt_toolkit.formatted_text.base import AnyFormattedText
+
+
+class MessageWindow(ConditionalContainer):
+    """Main window to display question to the user.
+
+    Args:
+        message: The message to display in the terminal.
+        filter: Condition that this message window should be displayed.
+            Use a loading condition to only display this window while its not loading.
+        wrap_lines: Enable line wrapping if the message is too long.
+        show_cursor: Display cursor.
+    """
+
+    def __init__(
+        self,
+        message: "AnyFormattedText",
+        filter: "FilterOrBool",
+        wrap_lines: bool = True,
+        show_cursor: bool = True,
+        **kwargs
+    ) -> None:
+        super().__init__(
+            content=Window(
+                height=LayoutDimension.exact(1) if not wrap_lines else None,
+                content=FormattedTextControl(message, show_cursor=show_cursor),
+                wrap_lines=wrap_lines,
+                dont_extend_height=True,
+                **kwargs
+            ),
+            filter=filter,
+        )

.env/lib/python3.12/site-packages/InquirerPy/containers/spinner.py

@@ -0,0 +1,108 @@
+"""Module contains spinner related resources.
+
+Note:
+    The spinner is not a standalone spinner to run in the terminal
+    but rather a `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner.
+
+    Use library such as `yaspin <https://github.com/pavdmyt/yaspin>`_ if you need a plain spinner.
+"""
+import asyncio
+from typing import TYPE_CHECKING, Callable, List, NamedTuple, Optional, Tuple, Union
+
+from prompt_toolkit.filters.utils import to_filter
+from prompt_toolkit.layout.containers import ConditionalContainer, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+if TYPE_CHECKING:
+    from prompt_toolkit.filters.base import Filter
+
+__all__ = ["SPINNERS", "SpinnerWindow"]
+
+
+class SPINNERS(NamedTuple):
+    """Presets of spinner patterns.
+
+    See Also:
+        https://github.com/pavdmyt/yaspin/blob/master/yaspin/data/spinners.json
+
+    This only contains some basic ones thats ready to use. For more patterns, checkout the
+    URL above.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> from InquirerPy.spinner import SPINNERS
+        >>> inquirer.select(message="", choices=lambda _: [1, 2, 3], spinner_pattern=SPINNERS.dots)
+    """
+
+    dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    dots2 = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]
+    line = ["-", "\\", "|", "/"]
+    line2 = ["⠂", "-", "–", "—", "–", "-"]
+    pipe = ["┤", "┘", "┴", "└", "├", "┌", "┬", "┐"]
+    star = ["✶", "✸", "✹", "✺", "✹", "✷"]
+    star2 = ["+", "x", "*"]
+    flip = ["_", "_", "_", "-", "`", "`", "'", "´", "-", "_", "_", "_"]
+    hamburger = ["☱", "☲", "☴"]
+    grow_vertical = ["▁", "▃", "▄", "▅", "▆", "▇", "▆", "▅", "▄", "▃"]
+    grow_horizontal = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "▊", "▋", "▌", "▍", "▎"]
+    box_bounce = ["▖", "▘", "▝", "▗"]
+    triangle = ["◢", "◣", "◤", "◥"]
+    arc = ["◜", "◠", "◝", "◞", "◡", "◟"]
+    circle = ["◡", "⊙", "◠"]
+
+
+class SpinnerWindow(ConditionalContainer):
+    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner.
+
+    Args:
+        loading: A :class:`~prompt_toolkit.filters.Condition` to indicate if the spinner should be visible.
+        redraw: A redraw function (i.e. :meth:`~prompt_toolkit.application.Application.invalidate`) to refresh the UI.
+        pattern: List of pattern to display as the spinner.
+        delay: Spinner refresh frequency.
+        text: Loading text to display.
+    """
+
+    def __init__(
+        self,
+        loading: "Filter",
+        redraw: Callable[[], None],
+        pattern: Optional[Union[List[str], SPINNERS]] = None,
+        delay: float = 0.1,
+        text: str = "",
+    ) -> None:
+        self._loading = to_filter(loading)
+        self._spinning = False
+        self._redraw = redraw
+        self._pattern = pattern or SPINNERS.line
+        self._char = self._pattern[0]
+        self._delay = delay
+        self._text = text or "Loading ..."
+
+        super().__init__(
+            content=Window(content=FormattedTextControl(text=self._get_text)),
+            filter=self._loading,
+        )
+
+    def _get_text(self) -> List[Tuple[str, str]]:
+        """Dynamically get the text for the :class:`~prompt_toolkit.layout.Window`.
+
+        Returns:
+            Formatted text.
+        """
+        return [
+            ("class:spinner_pattern", self._char),
+            ("", " "),
+            ("class:spinner_text", self._text),
+        ]
+
+    async def start(self) -> None:
+        """Start the spinner."""
+        if self._spinning:
+            return
+        self._spinning = True
+        while self._loading():
+            for char in self._pattern:
+                await asyncio.sleep(self._delay)
+                self._char = char
+                self._redraw()
+        self._spinning = False

.env/lib/python3.12/site-packages/InquirerPy/containers/validation.py

@@ -0,0 +1,60 @@
+"""Module contains :class:`.ValidationWindow` which can be used to display error."""
+
+from typing import Optional
+
+from prompt_toolkit.filters.base import FilterOrBool
+from prompt_toolkit.formatted_text.base import AnyFormattedText
+from prompt_toolkit.layout.containers import ConditionalContainer, Float, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+
+class ValidationWindow(ConditionalContainer):
+    """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays error.
+
+    Args:
+        invalid_message: Error message to display when error occured.
+        filter: Condition to display the error window.
+    """
+
+    def __init__(
+        self, invalid_message: AnyFormattedText, filter: FilterOrBool, **kwargs
+    ) -> None:
+        super().__init__(
+            Window(
+                FormattedTextControl(invalid_message), dont_extend_height=True, **kwargs
+            ),
+            filter=filter,
+        )
+
+
+class ValidationFloat(Float):
+    """:class:`~prompt_toolkit.layout.Float` wrapper around :class:`.ValidationWindow`.
+
+    Args:
+        invalid_message: Error message to display when error occured.
+        filter: Condition to display the error window.
+        left: Distance to left.
+        right: Distance to right.
+        bottom: Distance to bottom.
+        top: Distance to top.
+    """
+
+    def __init__(
+        self,
+        invalid_message: AnyFormattedText,
+        filter: FilterOrBool,
+        left: Optional[int] = None,
+        right: Optional[int] = None,
+        bottom: Optional[int] = None,
+        top: Optional[int] = None,
+        **kwargs
+    ) -> None:
+        super().__init__(
+            content=ValidationWindow(
+                invalid_message=invalid_message, filter=filter, **kwargs
+            ),
+            left=left,
+            right=right,
+            bottom=bottom,
+            top=top,
+        )

.env/lib/python3.12/site-packages/InquirerPy/enum.py

@@ -0,0 +1,7 @@
+"""Module contains common constants."""
+INQUIRERPY_KEYBOARD_INTERRUPT: str = "INQUIRERPY_KEYBOARD_INTERRUPT"
+
+INQUIRERPY_POINTER_SEQUENCE: str = "\u276f"
+INQUIRERPY_FILL_CIRCLE_SEQUENCE: str = "\u25c9"
+INQUIRERPY_EMPTY_CIRCLE_SEQUENCE: str = "\u25cb"
+INQUIRERPY_QMARK_SEQUENCE: str = "\u003f"

.env/lib/python3.12/site-packages/InquirerPy/exceptions.py

@@ -0,0 +1,25 @@
+"""Module contains exceptions that will be raised by `InquirerPy`."""
+
+
+class InvalidArgument(Exception):
+    """Provided argument is invalid.
+
+    Args:
+        message: Exception message.
+    """
+
+    def __init__(self, message: str = "invalid argument"):
+        self._message = message
+        super().__init__(self._message)
+
+
+class RequiredKeyNotFound(Exception):
+    """Missing required keys in dictionary.
+
+    Args:
+        message: Exception message.
+    """
+
+    def __init__(self, message="required key not found"):
+        self.message = message
+        super().__init__(self.message)

.env/lib/python3.12/site-packages/InquirerPy/inquirer.py

@@ -0,0 +1,17 @@
+"""Servers as another entry point for `InquirerPy`.
+
+See Also:
+    :ref:`index:Alternate Syntax`.
+
+`inquirer` directly interact with individual prompt classes. It’s more flexible, easier to customise and also provides IDE type hintings/completions.
+"""
+from InquirerPy.prompts import CheckboxPrompt as checkbox
+from InquirerPy.prompts import ConfirmPrompt as confirm
+from InquirerPy.prompts import ExpandPrompt as expand
+from InquirerPy.prompts import FilePathPrompt as filepath
+from InquirerPy.prompts import FuzzyPrompt as fuzzy
+from InquirerPy.prompts import InputPrompt as text
+from InquirerPy.prompts import ListPrompt as select
+from InquirerPy.prompts import NumberPrompt as number
+from InquirerPy.prompts import RawlistPrompt as rawlist
+from InquirerPy.prompts import SecretPrompt as secret

.env/lib/python3.12/site-packages/InquirerPy/prompts/__init__.py

@@ -0,0 +1,11 @@
+"""Module contains import of all prompts classes."""
+from InquirerPy.prompts.checkbox import CheckboxPrompt
+from InquirerPy.prompts.confirm import ConfirmPrompt
+from InquirerPy.prompts.expand import ExpandPrompt
+from InquirerPy.prompts.filepath import FilePathPrompt
+from InquirerPy.prompts.fuzzy import FuzzyPrompt
+from InquirerPy.prompts.input import InputPrompt
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.prompts.number import NumberPrompt
+from InquirerPy.prompts.rawlist import RawlistPrompt
+from InquirerPy.prompts.secret import SecretPrompt

.env/lib/python3.12/site-packages/InquirerPy/prompts/checkbox.py

@@ -0,0 +1,244 @@
+"""Module contains the class to create a checkbox prompt."""
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from prompt_toolkit.validation import ValidationError
+
+from InquirerPy.base import FakeDocument, InquirerPyUIListControl
+from InquirerPy.enum import (
+    INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
+    INQUIRERPY_FILL_CIRCLE_SEQUENCE,
+    INQUIRERPY_POINTER_SEQUENCE,
+)
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.separator import Separator
+from InquirerPy.utils import (
+    InquirerPyKeybindings,
+    InquirerPyListChoices,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+__all__ = ["CheckboxPrompt"]
+
+
+class InquirerPyCheckboxControl(InquirerPyUIListControl):
+    """An :class:`~prompt_toolkit.layout.UIControl` class that displays a list of choices.
+
+    Reference the parameter definition in :class:`.CheckboxPrompt`.
+    """
+
+    def __init__(
+        self,
+        choices: InquirerPyListChoices,
+        default: Any,
+        pointer: str,
+        enabled_symbol: str,
+        disabled_symbol: str,
+        session_result: Optional[InquirerPySessionResult],
+    ) -> None:
+        """Initialise required attributes and call base class."""
+        self._pointer = pointer
+        self._enabled_symbol = enabled_symbol
+        self._disabled_symbol = disabled_symbol
+        super().__init__(
+            choices=choices,
+            default=default,
+            session_result=session_result,
+            multiselect=True,
+        )
+
+    def _format_choices(self) -> None:
+        pass
+
+    def _get_hover_text(self, choice) -> List[Tuple[str, str]]:
+        display_choices = []
+        display_choices.append(("class:pointer", self._pointer))
+        if self._pointer:
+            display_choices.append(("", " "))
+        if not isinstance(choice["value"], Separator):
+            display_choices.append(
+                (
+                    "class:checkbox",
+                    self._enabled_symbol
+                    if choice["enabled"]
+                    else self._disabled_symbol,
+                )
+            )
+            if self._enabled_symbol and self._disabled_symbol:
+                display_choices.append(("", " "))
+        display_choices.append(("[SetCursorPosition]", ""))
+        display_choices.append(("class:pointer", choice["name"]))
+        return display_choices
+
+    def _get_normal_text(self, choice) -> List[Tuple[str, str]]:
+        display_choices = []
+        display_choices.append(("", len(self._pointer) * " "))
+        if self._pointer:
+            display_choices.append(("", " "))
+        if not isinstance(choice["value"], Separator):
+            display_choices.append(
+                (
+                    "class:checkbox",
+                    self._enabled_symbol
+                    if choice["enabled"]
+                    else self._disabled_symbol,
+                )
+            )
+            if self._enabled_symbol and self._disabled_symbol:
+                display_choices.append(("", " "))
+            display_choices.append(("", choice["name"]))
+        else:
+            display_choices.append(("class:separator", choice["name"]))
+        return display_choices
+
+
+class CheckboxPrompt(ListPrompt):
+    """Create a prompt which displays a list of checkboxes to toggle.
+
+    A wrapper class around :class:`~prompt_toolkit.application.Application`.
+
+    User can toggle on/off on each checkbox.
+
+    Works very similar to :class:`~InquirerPy.prompts.list.ListPrompt` with `multiselect` enabled,
+    the main difference is visual/UI and also when not toggling anything, the result will be empty.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        choices: List of choices to display and select.
+            Refer to :ref:`pages/dynamic:choices` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Use vim keybinding for the prompt.
+            Refer to :ref:`pages/kb:Keybindings` documentation for more details.
+        default: Set the default value of the prompt.
+            This will be used to determine which choice is highlighted (current selection),
+            The default value should be the value of one of the choices.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        separator: Separator symbol. Custom symbol that will be used as a separator between the choice index number and the choices.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        pointer: Pointer symbol. Customer symbol that will be used to indicate the current choice selection.
+        enabled_symbol: Checkbox ticked symbol. Custom symbol which indicate the checkbox is ticked.
+        disabled_symbol: Checkbox not ticked symbol. Custom symbol which indicate the checkbox is not ticked.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        validate: Add validation to user input.
+            The main use case for this prompt would be when `multiselect` is True, you can enforce a min/max selection.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        invalid_message: Error message to display when user input is invalid.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        height: Preferred height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        max_height: Max height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        border: Create border around the choice window.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        show_cursor: Display cursor at the end of the prompt.
+            Set to False to hide the cursor.
+        cycle: Return to top item if hit bottom during navigation or vice versa.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.checkbox(message="Select:", choices=[1, 2, 3]).execute()
+        >>> print(result)
+        [1]
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        choices: InquirerPyListChoices,
+        default: Any = None,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        pointer: str = INQUIRERPY_POINTER_SEQUENCE,
+        enabled_symbol: str = INQUIRERPY_FILL_CIRCLE_SEQUENCE,
+        disabled_symbol: str = INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
+        border: bool = False,
+        instruction: str = "",
+        long_instruction: str = "",
+        transformer: Optional[Callable[[Any], Any]] = None,
+        filter: Optional[Callable[[Any], Any]] = None,
+        height: Optional[Union[int, str]] = None,
+        max_height: Optional[Union[int, str]] = None,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        show_cursor: bool = True,
+        cycle: bool = True,
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+    ) -> None:
+        self.content_control = InquirerPyCheckboxControl(
+            choices=choices,
+            default=default,
+            pointer=pointer,
+            enabled_symbol=enabled_symbol,
+            disabled_symbol=disabled_symbol,
+            session_result=session_result,
+        )
+        super().__init__(
+            message=message,
+            choices=choices,
+            style=style,
+            border=border,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            instruction=instruction,
+            long_instruction=long_instruction,
+            transformer=transformer,
+            filter=filter,
+            height=height,
+            max_height=max_height,
+            validate=validate,
+            invalid_message=invalid_message,
+            multiselect=True,
+            keybindings=keybindings,
+            show_cursor=show_cursor,
+            cycle=cycle,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+        )
+
+    def _handle_enter(self, event) -> None:
+        """Override this method to force empty array result.
+
+        When user does not select anything, exit with empty list.
+
+        Args:
+            event: Keypress event.
+        """
+        try:
+            fake_document = FakeDocument(self.result_value)
+            self._validator.validate(fake_document)  # type: ignore
+        except ValidationError:
+            self._invalid = True
+        else:
+            self.status["answered"] = True
+            self.status["result"] = self.result_name
+            event.app.exit(result=self.result_value)

.env/lib/python3.12/site-packages/InquirerPy/prompts/confirm.py

@@ -0,0 +1,196 @@
+"""Module contains the class to create a confirm prompt."""
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple
+
+from prompt_toolkit.buffer import ValidationState
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.shortcuts import PromptSession
+from prompt_toolkit.validation import ValidationError
+
+from InquirerPy.base import BaseSimplePrompt
+from InquirerPy.exceptions import InvalidArgument
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.input.base import Input
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+    from prompt_toolkit.output.base import Output
+
+__all__ = ["ConfirmPrompt"]
+
+
+class ConfirmPrompt(BaseSimplePrompt):
+    """Create a prompt that provides 2 options (confirm/deny) and controlled via single keypress.
+
+    A wrapper class around :class:`~prompt_toolkit.shortcuts.PromptSession`.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Used for compatibility .
+        default: Set the default value of the prompt, should be either `True` or `False`.
+            This affects the value returned when user directly hit `enter` key.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        confirm_letter: Letter used to confirm the prompt. A keybinding will be created for this letter.
+            Default is `y` and pressing `y` will answer the prompt with value `True`.
+        reject_letter: Letter used to reject the prompt. A keybinding will be created for this letter.
+            Default is `n` and pressing `n` will answer the prompt with value `False`.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+        input: Used internally and will be removed in future updates.
+        output: Used internally and will be removed in future updates.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.confirm(message="Confirm?").execute()
+        >>> print(result)
+        True
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        default: InquirerPyDefault = False,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        long_instruction: str = "",
+        transformer: Optional[Callable[[bool], Any]] = None,
+        filter: Optional[Callable[[bool], Any]] = None,
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        wrap_lines: bool = True,
+        confirm_letter: str = "y",
+        reject_letter: str = "n",
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+        input: Optional["Input"] = None,
+        output: Optional["Output"] = None,
+    ) -> None:
+        vi_mode = False
+        super().__init__(
+            message=message,
+            style=style,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            instruction=instruction,
+            transformer=transformer,
+            filter=filter,
+            default=default,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+        )
+        if not isinstance(self._default, bool):
+            raise InvalidArgument(
+                f"{type(self).__name__} argument default should be type of bool"
+            )
+        self._confirm_letter = confirm_letter
+        self._reject_letter = reject_letter
+
+        if not keybindings:
+            keybindings = {}
+        self.kb_maps = {
+            "confirm": [
+                {"key": self._confirm_letter},
+                {"key": self._confirm_letter.upper()},
+            ],
+            "reject": [
+                {"key": self._reject_letter},
+                {"key": self._reject_letter.upper()},
+            ],
+            "any": [{"key": Keys.Any}],
+            **keybindings,
+        }
+        self.kb_func_lookup = {
+            "confirm": [{"func": self._handle_confirm}],
+            "reject": [{"func": self._handle_reject}],
+            "any": [{"func": lambda _: None}],
+        }
+        self._keybinding_factory()
+
+        self._session = PromptSession(
+            message=self._get_prompt_message,
+            key_bindings=self._kb,
+            style=self._style,
+            wrap_lines=self._wrap_lines,
+            bottom_toolbar=[("class:long_instruction", long_instruction)]
+            if long_instruction
+            else None,
+            input=input,
+            output=output,
+        )
+
+    def _set_error(self, message: str) -> None:
+        self._session.default_buffer.validation_state = ValidationState.INVALID
+        self._session.default_buffer.validation_error = ValidationError(message=message)
+
+    def _handle_reject(self, event) -> None:
+        self._session.default_buffer.text = ""
+        self.status["answered"] = True
+        self.status["result"] = False
+        event.app.exit(result=False)
+
+    def _handle_confirm(self, event) -> None:
+        self._session.default_buffer.text = ""
+        self.status["answered"] = True
+        self.status["result"] = True
+        event.app.exit(result=True)
+
+    def _handle_enter(self, event: "KeyPressEvent") -> None:
+        self.status["answered"] = True
+        self.status["result"] = self._default
+        event.app.exit(result=self._default)
+
+    def _get_prompt_message(self) -> List[Tuple[str, str]]:
+        """Get message to display infront of the input buffer.
+
+        Returns:
+            Formatted text in list of tuple format.
+        """
+        if not self.instruction:
+            pre_answer = (
+                "class:instruction",
+                " (%s/%s) " % (self._confirm_letter.upper(), self._reject_letter)
+                if self._default
+                else " (%s/%s) " % (self._confirm_letter, self._reject_letter.upper()),
+            )
+        else:
+            pre_answer = ("class:instruction", " %s " % self.instruction)
+        post_answer = ("class:answer", " Yes" if self.status["result"] else " No")
+        return super()._get_prompt_message(pre_answer, post_answer)
+
+    def _run(self) -> bool:
+        return self._session.prompt()
+
+    async def _run_async(self) -> Any:
+        return await self._session.prompt_async()

.env/lib/python3.12/site-packages/InquirerPy/prompts/expand.py

@@ -0,0 +1,458 @@
+"""Module contains the class to create an expand prompt."""
+from dataclasses import dataclass
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from InquirerPy.base import BaseListPrompt, InquirerPyUIListControl
+from InquirerPy.base.control import Choice
+from InquirerPy.enum import INQUIRERPY_POINTER_SEQUENCE
+from InquirerPy.exceptions import InvalidArgument, RequiredKeyNotFound
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.separator import Separator
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyListChoices,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+__all__ = ["ExpandPrompt", "ExpandHelp", "ExpandChoice"]
+
+
+@dataclass
+class ExpandHelp:
+    """Help choice for the :class:`.ExpandPrompt`.
+
+    Args:
+        key: The key to bind to toggle the expansion of the prompt.
+        message: The help message.
+    """
+
+    key: str = "h"
+    message: str = "Help, list all choices"
+
+
+@dataclass
+class ExpandChoice(Choice):
+    """Choice class for :class:`.ExpandPrompt`.
+
+    See Also:
+        :class:`~InquirerPy.base.control.Choice`
+
+    Args:
+        value: The value of the choice when user selects this choice.
+        name: The value that should be presented to the user prior/after selection of the choice.
+            This value is optional, if not provided, it will fallback to the string representation of `value`.
+        enabled: Indicates if the choice should be pre-selected.
+            This only has effects when the prompt has `multiselect` enabled.
+        key: Char to bind to the choice. Pressing this value will jump to the choice,
+            If this value is missing, the first char of the `str(value)` will be used as the key.
+    """
+
+    key: Optional[str] = None
+
+    def __post_init__(self):
+        """Assign stringify value to name and also create key using the first char of the value if not present."""
+        super().__post_init__()
+        if self.key is None:
+            self.key = str(self.value)[0].lower()
+
+
+class InquirerPyExpandControl(InquirerPyUIListControl):
+    """An :class:`~prompt_toolkit.layout.UIControl` class that displays a list of choices.
+
+    Reference the parameter definition in :class:`.ExpandPrompt`.
+    """
+
+    def __init__(
+        self,
+        choices: InquirerPyListChoices,
+        default: Any,
+        pointer: str,
+        separator: str,
+        expand_help: ExpandHelp,
+        expand_pointer: str,
+        marker: str,
+        session_result: Optional[InquirerPySessionResult],
+        multiselect: bool,
+        marker_pl: str,
+    ) -> None:
+        self._pointer = pointer
+        self._separator = separator
+        self._expanded = False
+        self._expand_pointer = expand_pointer
+        self._marker = marker
+        self._marker_pl = marker_pl
+        self._expand_help = expand_help
+        super().__init__(
+            choices=choices,
+            default=default,
+            session_result=session_result,
+            multiselect=multiselect,
+        )
+
+    def _format_choices(self) -> None:
+        self._key_maps = {}
+        try:
+            count = 0
+            separator_count = 0
+            for raw_choice, choice in zip(self._raw_choices, self.choices):  # type: ignore
+                if (
+                    not isinstance(raw_choice, dict)
+                    and not isinstance(raw_choice, Separator)
+                    and not isinstance(raw_choice, ExpandChoice)
+                ):
+                    raise InvalidArgument(
+                        "expand prompt argument choices requires each choice to be type of dictionary or Separator or ExpandChoice"
+                    )
+                if isinstance(raw_choice, Separator):
+                    separator_count += 1
+                else:
+                    choice["key"] = (
+                        raw_choice.key
+                        if isinstance(raw_choice, ExpandChoice)
+                        else raw_choice["key"]
+                    )
+                    self._key_maps[choice["key"]] = count
+                count += 1
+        except KeyError:
+            raise RequiredKeyNotFound(
+                "expand prompt choice requires a key 'key' to exists"
+            )
+
+        self.choices.append(
+            {
+                "key": self._expand_help.key,
+                "value": self._expand_help,
+                "name": self._expand_help.message,
+                "enabled": False,
+            }
+        )
+        self._key_maps[self._expand_help.key] = len(self.choices) - 1
+
+        first_valid_choice_index = 0
+        while isinstance(self.choices[first_valid_choice_index]["value"], Separator):
+            first_valid_choice_index += 1
+        if self.selected_choice_index == first_valid_choice_index:
+            for index, choice in enumerate(self.choices):
+                if isinstance(choice["value"], Separator):
+                    continue
+                if choice["key"] == self._default:
+                    self.selected_choice_index = index
+                    break
+
+    def _get_formatted_choices(self) -> List[Tuple[str, str]]:
+        """Override this parent class method as expand require visual switch of content.
+
+        Two types of mode:
+            * non expand mode
+            * expand mode
+        """
+        if self._expanded:
+            return super()._get_formatted_choices()
+        else:
+            display_choices = []
+            display_choices.append(("class:pointer", self._expand_pointer))
+            display_choices.append(
+                ("", self.choices[self.selected_choice_index]["name"])
+            )
+        return display_choices
+
+    def _get_hover_text(self, choice) -> List[Tuple[str, str]]:
+        display_choices = []
+        display_choices.append(("class:pointer", self._pointer))
+        display_choices.append(
+            (
+                "class:marker",
+                self._marker if choice["enabled"] else self._marker_pl,
+            )
+        )
+        if not isinstance(choice["value"], Separator):
+            display_choices.append(
+                ("class:pointer", "%s%s" % (choice["key"], self._separator))
+            )
+        display_choices.append(("[SetCursorPosition]", ""))
+        display_choices.append(("class:pointer", choice["name"]))
+        return display_choices
+
+    def _get_normal_text(self, choice) -> List[Tuple[str, str]]:
+        display_choices = []
+        display_choices.append(("", len(self._pointer) * " "))
+        display_choices.append(
+            (
+                "class:marker",
+                self._marker if choice["enabled"] else self._marker_pl,
+            )
+        )
+        if not isinstance(choice["value"], Separator):
+            display_choices.append(("", "%s%s" % (choice["key"], self._separator)))
+            display_choices.append(("", choice["name"]))
+        else:
+            display_choices.append(("class:separator", choice["name"]))
+        return display_choices
+
+
+class ExpandPrompt(ListPrompt):
+    """Create a compact prompt with the ability to expand.
+
+    A wrapper class around :class:`~prompt_toolkit.application.Application`.
+
+    Contains a list of chocies binded to a shortcut letter.
+    The prompt can be expanded using `h` key.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        choices: List of choices to display and select.
+            Refer to :ref:`pages/prompts/expand:Choices` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Use vim keybinding for the prompt.
+            Refer to :ref:`pages/kb:Keybindings` documentation for more details.
+        default: Set the default value of the prompt.
+            This will be used to determine which choice is highlighted (current selection),
+            The default value should the value of one of the choices.
+            For :class:`.ExpandPrompt` specifically, default value can also be a `choice["key"]` which is the shortcut key for the choice.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        separator: Separator symbol. Custom symbol that will be used as a separator between the choice index number and the choices.
+        help_msg: This parameter is DEPRECATED. Use expand_help instead.
+        expand_help: The help configuration for the prompt. Must be an instance of :class:`.ExpandHelp`.
+            If this value is None, the default help key will be binded to `h` and the default help message would be
+            "Help, List all choices."
+        expand_pointer: Pointer symbol before prompt expansion. Custom symbol that will be displayed to indicate the prompt is not expanded.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        pointer: Pointer symbol. Customer symbol that will be used to indicate the current choice selection.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        validate: Add validation to user input.
+            The main use case for this prompt would be when `multiselect` is True, you can enforce a min/max selection.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        invalid_message: Error message to display when user input is invalid.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        height: Preferred height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        max_height: Max height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        multiselect: Enable multi-selection on choices.
+            You can use `validate` parameter to control min/max selections.
+            Setting to True will also change the result from a single value to a list of values.
+        marker: Marker Symbol. Custom symbol to indicate if a choice is selected.
+            This will take effects when `multiselect` is True.
+        marker_pl: Marker place holder when the choice is not selected.
+            This is empty space by default.
+        border: Create border around the choice window.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        show_cursor: Display cursor at the end of the prompt.
+            Set to False to hide the cursor.
+        cycle: Return to top item if hit bottom during navigation or vice versa.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.expand(message="Select one:", choices[{"name": "1", "value": "1", "key": "a"}]).execute()
+        >>> print(result)
+        "1"
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        choices: InquirerPyListChoices,
+        default: InquirerPyDefault = "",
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        pointer: str = " ",
+        separator: str = ") ",
+        help_msg: str = "Help, list all choices",
+        expand_help: Optional[ExpandHelp] = None,
+        expand_pointer: str = "%s " % INQUIRERPY_POINTER_SEQUENCE,
+        instruction: str = "",
+        long_instruction: str = "",
+        transformer: Optional[Callable[[Any], Any]] = None,
+        filter: Optional[Callable[[Any], Any]] = None,
+        height: Optional[Union[int, str]] = None,
+        max_height: Optional[Union[int, str]] = None,
+        multiselect: bool = False,
+        marker: str = INQUIRERPY_POINTER_SEQUENCE,
+        marker_pl: str = " ",
+        border: bool = False,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        show_cursor: bool = True,
+        cycle: bool = True,
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+    ) -> None:
+        if expand_help is None:
+            expand_help = ExpandHelp(message=help_msg)
+        self._expand_help = expand_help
+        self.content_control: InquirerPyExpandControl = InquirerPyExpandControl(
+            choices=choices,
+            default=default,
+            pointer=pointer,
+            separator=separator,
+            expand_help=expand_help,
+            expand_pointer=expand_pointer,
+            marker=marker,
+            marker_pl=marker_pl,
+            session_result=session_result,
+            multiselect=multiselect,
+        )
+        super().__init__(
+            message=message,
+            choices=choices,
+            style=style,
+            border=border,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            instruction=instruction,
+            long_instruction=long_instruction,
+            transformer=transformer,
+            filter=filter,
+            height=height,
+            max_height=max_height,
+            validate=validate,
+            invalid_message=invalid_message,
+            multiselect=multiselect,
+            keybindings=keybindings,
+            show_cursor=show_cursor,
+            cycle=cycle,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+        )
+
+    def _on_rendered(self, _) -> None:
+        """Override this method to apply custom keybindings.
+
+        Needs to creat these kb in the callback due to `after_render`
+        retrieve the choices asynchronously.
+        """
+
+        def keybinding_factory(key):
+            @self.register_kb(key.lower())
+            def keybinding(_) -> None:
+                if key == self._expand_help.key:
+                    self.content_control._expanded = not self.content_control._expanded
+                else:
+                    self.content_control.selected_choice_index = (
+                        self.content_control._key_maps[key]
+                    )
+
+            return keybinding
+
+        for choice in self.content_control.choices:
+            if not isinstance(choice["value"], Separator):
+                keybinding_factory(choice["key"])
+
+    def _handle_up(self, event) -> None:
+        """Handle the event when user attempt to move up.
+
+        Overriding this method to skip the help choice.
+        """
+        if not self.content_control._expanded:
+            return
+        while True:
+            cap = BaseListPrompt._handle_up(self, event)
+            if not isinstance(
+                self.content_control.selection["value"], Separator
+            ) and not isinstance(self.content_control.selection["value"], ExpandHelp):
+                break
+            else:
+                if cap and not self._cycle:
+                    self._handle_down(event)
+                    break
+
+    def _handle_down(self, event) -> None:
+        """Handle the event when user attempt to move down.
+
+        Overriding this method to skip the help choice.
+        """
+        if not self.content_control._expanded:
+            return
+        while True:
+            cap = BaseListPrompt._handle_down(self, event)
+            if not isinstance(
+                self.content_control.selection["value"], Separator
+            ) and not isinstance(self.content_control.selection["value"], ExpandHelp):
+                break
+            elif (
+                isinstance(self.content_control.selection["value"], ExpandHelp)
+                and not self._cycle
+            ):
+                self._handle_up(event)
+                break
+            else:
+                if cap and not self._cycle:
+                    self._handle_up(event)
+                    break
+
+    @property
+    def instruction(self) -> str:
+        """Construct the instruction behind the question.
+
+        If _instruction exists, use that.
+
+        :return: The instruction text.
+        """
+        return (
+            "(%s)" % "".join(self.content_control._key_maps.keys())
+            if not self._instruction
+            else self._instruction
+        )
+
+    def _get_prompt_message(self) -> List[Tuple[str, str]]:
+        """Return the formatted text to display in the prompt.
+
+        Overriding this method to allow multiple formatted class to be displayed.
+        """
+        display_message = super()._get_prompt_message()
+        if not self.status["answered"]:
+            display_message.append(
+                ("class:input", self.content_control.selection["key"])
+            )
+        return display_message
+
+    def _handle_toggle_all(self, _, value: Optional[bool] = None) -> None:
+        """Override this method to ignore `ExpandHelp`.
+
+        :param value: Specify a value to toggle.
+        """
+        if not self.content_control._expanded:
+            return
+        for choice in self.content_control.choices:
+            if isinstance(choice["value"], Separator) or isinstance(
+                choice["value"], ExpandHelp
+            ):
+                continue
+            choice["enabled"] = value if value else not choice["enabled"]
+
+    def _handle_toggle_choice(self, event) -> None:
+        """Override this method to ignore keypress when not expanded."""
+        if not self.content_control._expanded:
+            return
+        super()._handle_toggle_choice(event)

.env/lib/python3.12/site-packages/InquirerPy/prompts/filepath.py

@@ -0,0 +1,192 @@
+"""Module contains the class to create filepath prompt and filepath completer class."""
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Generator, Optional
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion.base import ThreadedCompleter
+
+from InquirerPy.prompts.input import InputPrompt
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.input.base import Input
+    from prompt_toolkit.output.base import Output
+
+__all__ = ["FilePathPrompt", "FilePathCompleter"]
+
+
+class FilePathCompleter(Completer):
+    """An auto completion class which generates system filepath.
+
+    See Also:
+        :class:`~prompt_toolkit.completion.Completer`
+
+    Args:
+        only_directories: Only complete directories.
+        only_files: Only complete files.
+    """
+
+    def __init__(self, only_directories: bool = False, only_files: bool = False):
+        self._only_directories = only_directories
+        self._only_files = only_files
+        self._delimiter = "/" if os.name == "posix" else "\\"
+
+    def get_completions(
+        self, document, complete_event
+    ) -> Generator[Completion, None, None]:
+        """Get a list of valid system paths."""
+        if document.text == "~":
+            return
+
+        validation = lambda file, doc_text: str(file).startswith(doc_text)
+
+        if document.cursor_position == 0:
+            dirname = Path.cwd()
+            validation = lambda file, doc_text: True
+        elif document.text.startswith("~"):
+            dirname = Path(os.path.dirname(f"{Path.home()}{document.text[1:]}"))
+            validation = lambda file, doc_text: str(file).startswith(
+                f"{Path.home()}{doc_text[1:]}"
+            )
+        elif document.text.startswith(f".{self._delimiter}"):
+            dirname = Path(os.path.dirname(document.text))
+            validation = lambda file, doc_text: str(file).startswith(doc_text[2:])
+        else:
+            dirname = Path(os.path.dirname(document.text))
+
+        for item in self._get_completion(document, dirname, validation):
+            yield item
+
+    def _get_completion(
+        self, document, path, validation
+    ) -> Generator[Completion, None, None]:
+        if not path.is_dir():
+            return
+        for file in path.iterdir():
+            if self._only_directories and not file.is_dir():
+                continue
+            if self._only_files and not file.is_file():
+                continue
+            if validation(file, document.text):
+                file_name = file.name
+                display_name = file_name
+                if file.is_dir():
+                    display_name = f"{file_name}{self._delimiter}"
+                yield Completion(
+                    file.name,
+                    start_position=-1 * len(os.path.basename(document.text)),
+                    display=display_name,
+                )
+
+
+class FilePathPrompt(InputPrompt):
+    """Create a prompt that provides auto completion for system filepaths.
+
+    A wrapper class around :class:`~prompt_toolkit.shortcuts.PromptSession`.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Use vim keybinding for the prompt.
+            Refer to :ref:`pages/kb:Keybindings` documentation for more details.
+        default: Set the default text value of the prompt.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        multicolumn_complete: Change the auto-completion UI to a multi column display.
+        validate: Add validation to user input.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        invalid_message: Error message to display when user input is invalid.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        only_directories: Only complete directories.
+        only_files: Only complete files.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+        input: Used internally and will be removed in future updates.
+        output: Used internally and will be removed in future updates.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.filepath(message="Enter a path:").execute()
+        >>> print(result)
+        /home/ubuntu/README.md
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        default: InquirerPyDefault = "",
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        long_instruction: str = "",
+        multicolumn_complete: bool = False,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        only_directories: bool = False,
+        only_files: bool = False,
+        transformer: Optional[Callable[[str], Any]] = None,
+        filter: Optional[Callable[[str], Any]] = None,
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+        input: Optional["Input"] = None,
+        output: Optional["Output"] = None,
+    ) -> None:
+        super().__init__(
+            message=message,
+            style=style,
+            vi_mode=vi_mode,
+            default=default,
+            qmark=qmark,
+            amark=amark,
+            instruction=instruction,
+            long_instruction=long_instruction,
+            completer=ThreadedCompleter(
+                FilePathCompleter(
+                    only_directories=only_directories, only_files=only_files
+                )
+            ),
+            multicolumn_complete=multicolumn_complete,
+            validate=validate,
+            invalid_message=invalid_message,
+            transformer=transformer,
+            filter=filter,
+            keybindings=keybindings,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+            input=input,
+            output=output,
+        )

.env/lib/python3.12/site-packages/InquirerPy/prompts/fuzzy.py

@@ -0,0 +1,680 @@
+"""Module contains the class to create a fuzzy prompt."""
+import asyncio
+import math
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+from pfzy import fuzzy_match
+from pfzy.score import fzy_scorer, substr_scorer
+from pfzy.types import HAYSTACKS
+from prompt_toolkit.application.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters.cli import IsDone
+from prompt_toolkit.layout.containers import (
+    ConditionalContainer,
+    FloatContainer,
+    HSplit,
+    Window,
+)
+from prompt_toolkit.layout.controls import BufferControl, DummyControl
+from prompt_toolkit.layout.dimension import Dimension, LayoutDimension
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.layout.processors import AfterInput, BeforeInput
+from prompt_toolkit.lexers.base import SimpleLexer
+from prompt_toolkit.validation import ValidationError
+from prompt_toolkit.widgets.base import Frame
+
+from InquirerPy.base import FakeDocument, InquirerPyUIListControl
+from InquirerPy.base.list import BaseListPrompt
+from InquirerPy.containers.instruction import InstructionWindow
+from InquirerPy.containers.message import MessageWindow
+from InquirerPy.containers.validation import ValidationFloat
+from InquirerPy.enum import INQUIRERPY_POINTER_SEQUENCE
+from InquirerPy.exceptions import InvalidArgument
+from InquirerPy.separator import Separator
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyListChoices,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+    calculate_height,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+__all__ = ["FuzzyPrompt"]
+
+
+class InquirerPyFuzzyControl(InquirerPyUIListControl):
+    """An :class:`~prompt_toolkit.layout.UIControl` class that displays a list of choices.
+
+    This only displays the chocies. The actual input buffer will be handled by a separate
+    :class:`~prompt_toolkit.layout.BufferControl`.
+
+    Reference the parameter definition in :class:`.FuzzyPrompt`.
+    """
+
+    def __init__(
+        self,
+        choices: InquirerPyListChoices,
+        pointer: str,
+        marker: str,
+        current_text: Callable[[], str],
+        max_lines: int,
+        session_result: Optional[InquirerPySessionResult],
+        multiselect: bool,
+        marker_pl: str,
+        match_exact: bool,
+    ) -> None:
+        self._pointer = pointer
+        self._marker = marker
+        self._marker_pl = marker_pl
+        self._current_text = current_text
+        self._max_lines = max_lines if max_lines > 0 else 1
+        self._scorer = fzy_scorer if not match_exact else substr_scorer
+        super().__init__(
+            choices=choices,
+            default=None,
+            session_result=session_result,
+            multiselect=multiselect,
+        )
+
+    def _format_choices(self) -> None:
+        for index, choice in enumerate(self.choices):
+            if isinstance(choice["value"], Separator):
+                raise InvalidArgument(
+                    "fuzzy prompt argument choices should not contain Separator"
+                )
+            choice["index"] = index
+            choice["indices"] = []
+        self._filtered_choices = self.choices
+        self._first_line = 0
+        self._last_line = min(self._max_lines, self.choice_count)
+        self._height = self._last_line - self._first_line
+
+    def _get_hover_text(self, choice) -> List[Tuple[str, str]]:
+        """Get the current highlighted line of text.
+
+        If in the middle of filtering, loop through the char and color
+        indices matched char into style class `class:fuzzy_match`.
+
+        Returns:
+            FormattedText in list of tuple format.
+        """
+        display_choices = []
+        display_choices.append(("class:pointer", self._pointer))
+        display_choices.append(
+            (
+                "class:marker",
+                self._marker
+                if self.choices[choice["index"]]["enabled"]
+                else self._marker_pl,
+            )
+        )
+        display_choices.append(("[SetCursorPosition]", ""))
+        if not choice["indices"]:
+            display_choices.append(("class:pointer", choice["name"]))
+        else:
+            indices = set(choice["indices"])
+            for index, char in enumerate(choice["name"]):
+                if index in indices:
+                    display_choices.append(("class:fuzzy_match", char))
+                else:
+                    display_choices.append(("class:pointer", char))
+        return display_choices
+
+    def _get_normal_text(self, choice) -> List[Tuple[str, str]]:
+        """Get the line of text in `FormattedText`.
+
+        If in the middle of filtering, loop through the char and color
+        indices matched char into `class:fuzzy_match`.
+
+        Calculate spaces of pointer to make the choice equally align.
+
+        Returns:
+            FormattedText in list of tuple format.
+        """
+        display_choices = []
+        display_choices.append(("class:pointer", len(self._pointer) * " "))
+        display_choices.append(
+            (
+                "class:marker",
+                self._marker
+                if self.choices[choice["index"]]["enabled"]
+                else self._marker_pl,
+            )
+        )
+        if not choice["indices"]:
+            display_choices.append(("", choice["name"]))
+        else:
+            indices = set(choice["indices"])
+            for index, char in enumerate(choice["name"]):
+                if index in indices:
+                    display_choices.append(("class:fuzzy_match", char))
+                else:
+                    display_choices.append(("", char))
+        return display_choices
+
+    def _get_formatted_choices(self) -> List[Tuple[str, str]]:
+        """Get all available choices in formatted text format.
+
+        Overriding this method because `self.choice` will be the
+        full choice list. Using `self.filtered_choice` to get
+        a list of choice based on current_text.
+
+        Returns:
+            FormattedText in list of tuple format.
+        """
+        display_choices = []
+        if self.choice_count == 0:
+            self._selected_choice_index = 0
+            return display_choices
+
+        if self._selected_choice_index < 0:
+            self._selected_choice_index = 0
+        elif self._selected_choice_index >= self.choice_count:
+            self._selected_choice_index = self.choice_count - 1
+
+        if (self._last_line - self._first_line) < min(self.choice_count, self._height):
+            self._last_line = min(self.choice_count, self._height)
+            self._first_line = self._last_line - min(self.choice_count, self._height)
+
+        if self._selected_choice_index <= self._first_line:
+            self._first_line = self._selected_choice_index
+            self._last_line = self._first_line + min(self._height, self.choice_count)
+        elif self._selected_choice_index >= self._last_line:
+            self._last_line = self._selected_choice_index + 1
+            self._first_line = self._last_line - min(self._height, self.choice_count)
+
+        if self._last_line > self.choice_count:
+            self._last_line = self.choice_count
+            self._first_line = self._last_line - min(self._height, self.choice_count)
+        if self._first_line < 0:
+            self._first_line = 0
+            self._last_line = self._first_line + min(self._height, self.choice_count)
+
+        for index in range(self._first_line, self._last_line):
+            if index == self.selected_choice_index:
+                display_choices += self._get_hover_text(self._filtered_choices[index])
+            else:
+                display_choices += self._get_normal_text(self._filtered_choices[index])
+            display_choices.append(("", "\n"))
+        if display_choices:
+            display_choices.pop()
+        return display_choices
+
+    async def _filter_choices(self, wait_time: float) -> List[Dict[str, Any]]:
+        """Call to filter choices using fzy fuzzy match.
+
+        Args:
+            wait_time: Additional time to wait before filtering the choice.
+
+        Returns:
+            Filtered choices.
+        """
+        if not self._current_text():
+            for choice in self.choices:
+                choice["indices"] = []
+            choices = self.choices
+        else:
+            await asyncio.sleep(wait_time)
+            choices = await fuzzy_match(
+                self._current_text(),
+                cast(HAYSTACKS, self.choices),
+                key="name",
+                scorer=self._scorer,
+            )
+        return choices
+
+    @property
+    def selection(self) -> Dict[str, Any]:
+        """Override this value since `self.choice` does not indicate the choice displayed.
+
+        `self.filtered_choice` is the up to date choice displayed.
+
+        Returns:
+            A dictionary of name and value for the current pointed choice.
+        """
+        return self._filtered_choices[self.selected_choice_index]
+
+    @property
+    def choice_count(self) -> int:
+        """int: Filtered choice count."""
+        return len(self._filtered_choices)
+
+
+class FuzzyPrompt(BaseListPrompt):
+    """Create a prompt that lists choices while also allowing fuzzy search like fzf.
+
+    A wrapper class around :class:`~prompt_toolkit.application.Application`.
+
+    Fuzzy search using :func:`pfzy.match.fuzzy_match` function.
+
+    Override the default keybindings for up/down as j/k cannot be bind even if `editing_mode` is vim
+    due to the input buffer.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        choices: List of choices to display and select.
+            Refer to :ref:`pages/dynamic:choices` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Use vim keybinding for the prompt.
+            Refer to :ref:`pages/kb:Keybindings` documentation for more details.
+        default: Set the default value in the search buffer.
+            Different than other list type prompts, the `default` parameter tries to replicate what fzf does and
+            add the value in `default` to search buffer so it starts searching immediatelly.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        pointer: Pointer symbol. Customer symbol that will be used to indicate the current choice selection.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        validate: Add validation to user input.
+            The main use case for this prompt would be when `multiselect` is True, you can enforce a min/max selection.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        invalid_message: Error message to display when user input is invalid.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        height: Preferred height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        max_height: Max height of the prompt.
+            Refer to :ref:`pages/height:Height` documentation for more details.
+        multiselect: Enable multi-selection on choices.
+            You can use `validate` parameter to control min/max selections.
+            Setting to True will also change the result from a single value to a list of values.
+        prompt: Input prompt symbol. Custom symbol to display infront of the input buffer to indicate for input.
+        border: Create border around the choice window.
+        info: Display choice information similar to fzf --info=inline next to the prompt.
+        match_exact: Use exact sub-string match instead of using fzy fuzzy match algorithm.
+        exact_symbol: Custom symbol to display in the info section when `info=True`.
+        marker: Marker Symbol. Custom symbol to indicate if a choice is selected.
+            This will take effects when `multiselect` is True.
+        marker_pl: Marker place holder when the choice is not selected.
+            This is empty space by default.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        cycle: Return to top item if hit bottom during navigation or vice versa.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.fuzzy(message="Select one:", choices=[1, 2, 3]).execute()
+        >>> print(result)
+        1
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        choices: InquirerPyListChoices,
+        default: InquirerPyDefault = "",
+        pointer: str = INQUIRERPY_POINTER_SEQUENCE,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        transformer: Optional[Callable[[Any], Any]] = None,
+        filter: Optional[Callable[[Any], Any]] = None,
+        instruction: str = "",
+        long_instruction: str = "",
+        multiselect: bool = False,
+        prompt: str = INQUIRERPY_POINTER_SEQUENCE,
+        marker: str = INQUIRERPY_POINTER_SEQUENCE,
+        marker_pl: str = " ",
+        border: bool = False,
+        info: bool = True,
+        match_exact: bool = False,
+        exact_symbol: str = " E",
+        height: Optional[Union[str, int]] = None,
+        max_height: Optional[Union[str, int]] = None,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        cycle: bool = True,
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+    ) -> None:
+        if not keybindings:
+            keybindings = {}
+        self._prompt = prompt
+        self._info = info
+        self._task = None
+        self._rendered = False
+        self._exact_symbol = exact_symbol
+
+        keybindings = {
+            "up": [{"key": "up"}, {"key": "c-p"}],
+            "down": [{"key": "down"}, {"key": "c-n"}],
+            "toggle": [],
+            "toggle-exact": [],
+            **keybindings,
+        }
+        super().__init__(
+            message=message,
+            style=style,
+            border=border,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            transformer=transformer,
+            filter=filter,
+            validate=validate,
+            invalid_message=invalid_message,
+            multiselect=multiselect,
+            instruction=instruction,
+            long_instruction=long_instruction,
+            keybindings=keybindings,
+            cycle=cycle,
+            wrap_lines=wrap_lines,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            session_result=session_result,
+        )
+        self.kb_func_lookup = {"toggle-exact": [{"func": self._toggle_exact}]}
+        self._default = (
+            default
+            if not isinstance(default, Callable)
+            else cast(Callable, default)(self._result)
+        )
+        self._height_offset += 1  # search input
+        self._dimmension_height, self._dimmension_max_height = calculate_height(
+            height, max_height, height_offset=self.height_offset
+        )
+
+        self._content_control: InquirerPyFuzzyControl = InquirerPyFuzzyControl(
+            choices=choices,
+            pointer=pointer,
+            marker=marker,
+            current_text=self._get_current_text,
+            max_lines=self._dimmension_max_height,
+            session_result=session_result,
+            multiselect=multiselect,
+            marker_pl=marker_pl,
+            match_exact=match_exact,
+        )
+
+        self._buffer = Buffer(on_text_changed=self._on_text_changed)
+        input_window = Window(
+            height=LayoutDimension.exact(1),
+            content=BufferControl(
+                self._buffer,
+                [
+                    AfterInput(self._generate_after_input),
+                    BeforeInput(self._generate_before_input),
+                ],
+                lexer=SimpleLexer("class:input"),
+            ),
+        )
+
+        choice_height_dimmension = lambda: Dimension(
+            max=self._dimmension_max_height,
+            preferred=self._dimmension_height,
+            min=self.content_control._height if self.content_control._height > 0 else 1,
+        )
+        self.choice_window = Window(
+            content=self.content_control,
+            height=choice_height_dimmension,
+            dont_extend_height=True,
+        )
+
+        main_content_window = HSplit([input_window, self.choice_window])
+        if self._border:
+            main_content_window = Frame(main_content_window)
+        self._layout = Layout(
+            FloatContainer(
+                content=HSplit(
+                    [
+                        MessageWindow(
+                            message=self._get_prompt_message,
+                            filter=True,
+                            wrap_lines=self._wrap_lines,
+                            show_cursor=True,
+                        ),
+                        ConditionalContainer(
+                            main_content_window,
+                            filter=~IsDone(),
+                        ),
+                        ConditionalContainer(
+                            Window(content=DummyControl()),
+                            filter=~IsDone() & self._is_displaying_long_instruction,
+                        ),
+                        InstructionWindow(
+                            message=self._long_instruction,
+                            filter=~IsDone() & self._is_displaying_long_instruction,
+                            wrap_lines=self._wrap_lines,
+                        ),
+                    ],
+                ),
+                floats=[
+                    ValidationFloat(
+                        invalid_message=self._get_error_message,
+                        filter=self._is_invalid & ~IsDone(),
+                        wrap_lines=self._wrap_lines,
+                        left=0,
+                        bottom=self._validation_window_bottom_offset,
+                    ),
+                ],
+            )
+        )
+        self._layout.focus(input_window)
+
+        self._application = Application(
+            layout=self._layout,
+            style=self._style,
+            key_bindings=self._kb,
+            editing_mode=self._editing_mode,
+            after_render=self._after_render,
+        )
+
+    def _toggle_exact(self, _, value: Optional[bool] = None) -> None:
+        """Toggle matching algorithm.
+
+        Switch between fzy fuzzy match or sub-string exact match.
+
+        Args:
+            value: Specify the value to toggle.
+        """
+        if value is not None:
+            self.content_control._scorer = fzy_scorer if not value else substr_scorer
+        else:
+            self.content_control._scorer = (
+                fzy_scorer
+                if self.content_control._scorer == substr_scorer
+                else substr_scorer
+            )
+
+    def _on_rendered(self, _) -> None:
+        """Render callable choices and set the buffer default text.
+
+        Setting buffer default text has to be after application is rendered and choice are loaded,
+        because `self._filter_choices` will use the event loop from `Application`.
+        """
+        if self._default:
+            default_text = str(self._default)
+            self._buffer.text = default_text
+            self._buffer.cursor_position = len(default_text)
+
+    def _handle_toggle_all(self, _, value: Optional[bool] = None) -> None:
+        """Toggle all choice `enabled` status.
+
+        Args:
+            value: Specify the value to toggle.
+        """
+        if not self._multiselect:
+            return
+        for choice in self.content_control._filtered_choices:
+            raw_choice = self.content_control.choices[choice["index"]]
+            if isinstance(raw_choice["value"], Separator):
+                continue
+            raw_choice["enabled"] = value if value else not raw_choice["enabled"]
+
+    def _generate_after_input(self) -> List[Tuple[str, str]]:
+        """Virtual text displayed after the user input."""
+        display_message = []
+        if self._info:
+            display_message.append(("", "  "))
+            display_message.append(
+                (
+                    "class:fuzzy_info",
+                    f"{self.content_control.choice_count}/{len(self.content_control.choices)}",
+                )
+            )
+            if self._multiselect:
+                display_message.append(
+                    ("class:fuzzy_info", f" ({len(self.selected_choices)})")
+                )
+            if self.content_control._scorer == substr_scorer:
+                display_message.append(("class:fuzzy_info", self._exact_symbol))
+        return display_message
+
+    def _generate_before_input(self) -> List[Tuple[str, str]]:
+        """Display prompt symbol as virtual text before user input."""
+        display_message = []
+        display_message.append(("class:fuzzy_prompt", "%s " % self._prompt))
+        return display_message
+
+    def _filter_callback(self, task):
+        """Redraw `self._application` when the filter task is finished."""
+        if task.cancelled():
+            return
+        self.content_control._filtered_choices = task.result()
+        self._application.invalidate()
+
+    def _calculate_wait_time(self) -> float:
+        """Calculate wait time to smoother the application on big data set.
+
+        Using digit of the choices lengeth to get wait time.
+        For digit greater than 6, using formula 2^(digit - 5) * 0.3 to increase the wait_time.
+
+        Returns:
+            Desired wait time before running the filter.
+        """
+        wait_table = {
+            2: 0.05,
+            3: 0.1,
+            4: 0.2,
+            5: 0.3,
+        }
+        digit = 1
+        if len(self.content_control.choices) > 0:
+            digit = int(math.log10(len(self.content_control.choices))) + 1
+
+        if digit < 2:
+            return 0.0
+        if digit in wait_table:
+            return wait_table[digit]
+        return wait_table[5] * (2 ** (digit - 5))
+
+    def _on_text_changed(self, _) -> None:
+        """Handle buffer text change event.
+
+        1. Check if there is current task running.
+        2. Cancel if already has task, increase wait_time
+        3. Create a filtered_choice task in asyncio event loop
+        4. Add callback
+
+        1. Run a new filter on all choices.
+        2. Re-calculate current selected_choice_index
+            if it exceeds the total filtered_choice.
+        3. Avoid selected_choice_index less than zero,
+            this fix the issue of cursor lose when:
+            choice -> empty choice -> choice
+
+        Don't need to create or check asyncio event loop, `prompt_toolkit`
+        application already has a event loop running.
+        """
+        if self._invalid:
+            self._invalid = False
+        wait_time = self._calculate_wait_time()
+        if self._task and not self._task.done():
+            self._task.cancel()
+        self._task = asyncio.create_task(
+            self.content_control._filter_choices(wait_time)
+        )
+        self._task.add_done_callback(self._filter_callback)
+
+    def _handle_toggle_choice(self, _) -> None:
+        """Handle tab event, alter the `selected` state of the choice."""
+        if not self._multiselect:
+            return
+        current_selected_index = self.content_control.selection["index"]
+        self.content_control.choices[current_selected_index][
+            "enabled"
+        ] = not self.content_control.choices[current_selected_index]["enabled"]
+
+    def _handle_enter(self, event: "KeyPressEvent") -> None:
+        """Handle enter event.
+
+        Validate the result first.
+
+        In multiselect scenario, if no TAB is entered, then capture the current
+        highlighted choice and return the value in a list.
+        Otherwise, return all TAB choices as a list.
+
+        In normal scenario, reutrn the current highlighted choice.
+
+        If current UI contains no choice due to filter, return None.
+        """
+        try:
+            fake_document = FakeDocument(self.result_value)
+            self._validator.validate(fake_document)  # type: ignore
+            if self._multiselect:
+                self.status["answered"] = True
+                if not self.selected_choices:
+                    self.status["result"] = [self.content_control.selection["name"]]
+                    event.app.exit(result=[self.content_control.selection["value"]])
+                else:
+                    self.status["result"] = self.result_name
+                    event.app.exit(result=self.result_value)
+            else:
+                self.status["answered"] = True
+                self.status["result"] = self.content_control.selection["name"]
+                event.app.exit(result=self.content_control.selection["value"])
+        except ValidationError as e:
+            self._set_error(str(e))
+        except IndexError:
+            self.status["answered"] = True
+            self.status["result"] = None if not self._multiselect else []
+            event.app.exit(result=None if not self._multiselect else [])
+
+    @property
+    def content_control(self) -> InquirerPyFuzzyControl:
+        """InquirerPyFuzzyControl: Override for type-hinting."""
+        return cast(InquirerPyFuzzyControl, super().content_control)
+
+    @content_control.setter
+    def content_control(self, value: InquirerPyFuzzyControl) -> None:
+        self._content_control = value
+
+    def _get_current_text(self) -> str:
+        """Get current input buffer text."""
+        return self._buffer.text

.env/lib/python3.12/site-packages/InquirerPy/prompts/input.py

@@ -0,0 +1,253 @@
+"""Module contains the class to create an input prompt."""
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+
+from prompt_toolkit.buffer import ValidationState
+from prompt_toolkit.completion import NestedCompleter
+from prompt_toolkit.completion.base import Completer
+from prompt_toolkit.filters.base import Condition
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.lexers import SimpleLexer
+from prompt_toolkit.shortcuts.prompt import CompleteStyle, PromptSession
+from prompt_toolkit.validation import ValidationError
+
+from InquirerPy.base import BaseSimplePrompt
+from InquirerPy.enum import INQUIRERPY_POINTER_SEQUENCE
+from InquirerPy.exceptions import InvalidArgument
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.input.base import Input
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+    from prompt_toolkit.output.base import Output
+
+__all__ = ["InputPrompt"]
+
+
+class InputPrompt(BaseSimplePrompt):
+    """Create a text prompt that accepts user input.
+
+    A wrapper class around :class:`~prompt_toolkit.shortcuts.PromptSession`.
+
+    Args:
+        message: The question to ask the user.
+            Refer to :ref:`pages/dynamic:message` documentation for more details.
+        style: An :class:`InquirerPyStyle` instance.
+            Refer to :ref:`Style <pages/style:Alternate Syntax>` documentation for more details.
+        vi_mode: Use vim keybinding for the prompt.
+            Refer to :ref:`pages/kb:Keybindings` documentation for more details.
+        default: Set the default text value of the prompt.
+            Refer to :ref:`pages/dynamic:default` documentation for more details.
+        qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered.
+        amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered.
+        instruction: Short instruction to display next to the question.
+        long_instruction: Long instructions to display at the bottom of the prompt.
+        completer: Add auto completion to the prompt.
+            Refer to :ref:`pages/prompts/input:Auto Completion` documentation for more details.
+        multicolumn_complete: Change the auto-completion UI to a multi column display.
+        multiline: Enable multiline edit. While multiline edit is active, pressing `enter` won't complete the answer.
+            and will create a new line. Use `esc` followd by `enter` to complete the question.
+        validate: Add validation to user input.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        invalid_message: Error message to display when user input is invalid.
+            Refer to :ref:`pages/validator:Validator` documentation for more details.
+        transformer: A function which performs additional transformation on the value that gets printed to the terminal.
+            Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:transformer` documentation for more details.
+        filter: A function which performs additional transformation on the result.
+            This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`.
+            Refer to :ref:`pages/dynamic:filter` documentation for more details.
+        keybindings: Customise the builtin keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more details.
+        wrap_lines: Soft wrap question lines when question exceeds the terminal width.
+        raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result
+            will be `None` and the question is skiped.
+        is_password: Used internally for :class:`~InquirerPy.prompts.secret.SecretPrompt`.
+        mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped.
+        mandatory_message: Error message to show when user attempts to skip mandatory prompt.
+        session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`.
+        input: Used internally and will be removed in future updates.
+        output: Used internally and will be removed in future updates.
+
+    Examples:
+        >>> from InquirerPy import inquirer
+        >>> result = inquirer.text(message="Enter your name:").execute()
+        >>> print(f"Name: {result}")
+        Name: Michael
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        default: InquirerPyDefault = "",
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        long_instruction: str = "",
+        completer: Optional[Union[Dict[str, Optional[str]], "Completer"]] = None,
+        multicolumn_complete: bool = False,
+        multiline: bool = False,
+        validate: Optional[InquirerPyValidate] = None,
+        invalid_message: str = "Invalid input",
+        transformer: Optional[Callable[[str], Any]] = None,
+        filter: Optional[Callable[[str], Any]] = None,
+        keybindings: Optional[InquirerPyKeybindings] = None,
+        wrap_lines: bool = True,
+        raise_keyboard_interrupt: bool = True,
+        is_password: bool = False,
+        mandatory: bool = True,
+        mandatory_message: str = "Mandatory prompt",
+        session_result: Optional[InquirerPySessionResult] = None,
+        input: Optional["Input"] = None,
+        output: Optional["Output"] = None,
+    ) -> None:
+        super().__init__(
+            message,
+            style,
+            vi_mode=vi_mode,
+            qmark=qmark,
+            amark=amark,
+            instruction=instruction,
+            validate=validate,
+            invalid_message=invalid_message,
+            transformer=transformer,
+            filter=filter,
+            session_result=session_result,
+            default=default,
+            wrap_lines=wrap_lines,
+            mandatory=mandatory,
+            mandatory_message=mandatory_message,
+            raise_keyboard_interrupt=raise_keyboard_interrupt,
+        )
+        if not isinstance(self._default, str):
+            raise InvalidArgument(
+                f"{type(self).__name__} argument 'default' should be type of str"
+            )
+        self._completer = None
+        if isinstance(completer, dict):
+            self._completer = NestedCompleter.from_nested_dict(completer)
+        elif isinstance(completer, Completer):
+            self._completer = completer
+        self._multiline = multiline
+        self._complete_style = (
+            CompleteStyle.COLUMN
+            if not multicolumn_complete
+            else CompleteStyle.MULTI_COLUMN
+        )
+
+        @Condition
+        def is_multiline():
+            return self._multiline
+
+        if not keybindings:
+            keybindings = {}
+        self.kb_maps = {
+            "answer": [
+                {"key": Keys.Enter, "filter": ~is_multiline},
+                {"key": [Keys.Escape, Keys.Enter], "filter": is_multiline},
+            ],
+            "completion": [{"key": "c-space"}],
+            **keybindings,
+        }
+        self.kb_func_lookup = {"completion": [{"func": self._handle_completion}]}
+        self._keybinding_factory()
+
+        self._session = PromptSession(
+            message=self._get_prompt_message,
+            key_bindings=self._kb,
+            style=self._style,
+            completer=self._completer,
+            validator=self._validator,
+            validate_while_typing=False,
+            input=input,
+            output=output,
+            editing_mode=self._editing_mode,
+            lexer=SimpleLexer(self._lexer),
+            is_password=is_password,
+            multiline=self._multiline,
+            complete_style=self._complete_style,
+            wrap_lines=wrap_lines,
+            bottom_toolbar=[("class:long_instruction", long_instruction)]
+            if long_instruction
+            else None,
+        )
+
+    def _set_error(self, message: str) -> None:
+        self._session.default_buffer.validation_state = ValidationState.INVALID
+        self._session.default_buffer.validation_error = ValidationError(message=message)
+
+    def _handle_enter(self, event: "KeyPressEvent") -> None:
+        try:
+            self._session.validator.validate(self._session.default_buffer)  # type: ignore
+        except ValidationError:
+            self._session.default_buffer.validate_and_handle()
+        else:
+            self.status["answered"] = True
+            self.status["result"] = self._session.default_buffer.text
+            self._session.default_buffer.text = ""
+            event.app.exit(result=self.status["result"])
+
+    def _handle_completion(self, event) -> None:
+        if self._completer is None:
+            return
+        buff = event.app.current_buffer
+        if buff.complete_state:
+            buff.complete_next()
+        else:
+            buff.start_completion(select_first=False)
+
+    def _get_prompt_message(
+        self,
+        pre_answer: Optional[Tuple[str, str]] = None,
+        post_answer: Optional[Tuple[str, str]] = None,
+    ) -> List[Tuple[str, str]]:
+        """Get message to display infront of the input buffer.
+
+        Args:
+            pre_answer: The formatted text to display before answering the question.
+            post_answer: The formatted text to display after answering the question.
+
+        Returns:
+            Formatted text in list of tuple format.
+        """
+        if not pre_answer:
+            if self._multiline and not self._instruction:
+                pre_answer = ("class:instruction", " ESC + Enter to finish input")
+            else:
+                pre_answer = (
+                    "class:instruction",
+                    " %s " % self.instruction if self.instruction else " ",
+                )
+        if not post_answer:
+            if self._multiline and self.status["result"]:
+                lines = self.status["result"].split("\n")
+                if len(lines) > 1:
+                    number_of_chars = len("".join(lines[1:]))
+                    lines[0] += "...[%s char%s]" % (
+                        number_of_chars,
+                        "s" if number_of_chars > 1 else "",
+                    )
+                post_answer = ("class:answer", " %s" % lines[0])
+            else:
+                post_answer = ("class:answer", " %s" % self.status["result"])
+
+        formatted_message = super()._get_prompt_message(pre_answer, post_answer)
+        if not self.status["answered"] and self._multiline:
+            formatted_message.append(
+                ("class:questionmark", "\n%s " % INQUIRERPY_POINTER_SEQUENCE)
+            )
+        return formatted_message
+
+    def _run(self) -> str:
+        return self._session.prompt(default=self._default)
+
+    async def _run_async(self) -> Any:
+        return await self._session.prompt_async(default=self._default)