Delete files .local/ .npm/ with huggingface_hub

.local/bin/hf

@@ -1,7 +0,0 @@
-#!/usr/bin/python3.12
-import sys
-from huggingface_hub.cli.hf import main
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(main())

.local/bin/huggingface-cli

@@ -1,7 +0,0 @@
-#!/usr/bin/python3.12
-import sys
-from huggingface_hub.commands.huggingface_cli import main
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(main())

.local/bin/normalizer

@@ -1,7 +0,0 @@
-#!/usr/bin/python3.12
-import sys
-from charset_normalizer.cli import cli_detect
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(cli_detect())

.local/bin/tiny-agents

@@ -1,7 +0,0 @@
-#!/usr/bin/python3.12
-import sys
-from huggingface_hub.inference._mcp.cli import app
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(app())

.local/bin/tqdm

@@ -1,7 +0,0 @@
-#!/usr/bin/python3.12
-import sys
-from tqdm.cli import main
-if __name__ == '__main__':
-    if sys.argv[0].endswith('.exe'):
-        sys.argv[0] = sys.argv[0][:-4]
-    sys.exit(main())

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

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

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

@@ -1,15 +0,0 @@
-"""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

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

@@ -1,294 +0,0 @@
-"""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

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

@@ -1,227 +0,0 @@
-"""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

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

@@ -1,238 +0,0 @@
-"""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

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

@@ -1,378 +0,0 @@
-"""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}

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

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

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

@@ -1,38 +0,0 @@
-"""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)]

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

@@ -1,42 +0,0 @@
-"""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,
-        )

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

@@ -1,108 +0,0 @@
-"""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

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

@@ -1,60 +0,0 @@
-"""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,
-        )

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

@@ -1,7 +0,0 @@
-"""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"

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

@@ -1,25 +0,0 @@
-"""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)

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

@@ -1,17 +0,0 @@
-"""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

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

@@ -1,11 +0,0 @@
-"""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

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

@@ -1,244 +0,0 @@
-"""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)