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