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