InquirerPrompt 0.3.0__py3-none-any.whl

InquirerPy/prompts/rawlist.py

@@ -0,0 +1,286 @@
+"""Module contains the class to create a rawlist prompt."""
+
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from InquirerPy.base import InquirerPyUIListControl
+from InquirerPy.enum import INQUIRERPY_POINTER_SEQUENCE
+from InquirerPy.exceptions import InvalidArgument
+from InquirerPy.prompts.list import ListPrompt
+from InquirerPy.separator import Separator
+from InquirerPy.utils import (
+    InquirerPyDefault,
+    InquirerPyKeybindings,
+    InquirerPyListChoices,
+    InquirerPyMessage,
+    InquirerPySessionResult,
+    InquirerPyStyle,
+    InquirerPyValidate,
+)
+
+__all__ = ["RawlistPrompt"]
+
+
+class InquirerPyRawlistControl(InquirerPyUIListControl):
+    """An :class:`~prompt_toolkit.layout.UIControl` class that displays a list of choices.
+
+    Reference the parameter definition in :class:`.RawlistPrompt`.
+    """
+
+    def __init__(
+        self,
+        choices: InquirerPyListChoices,
+        default: Any,
+        pointer: str,
+        separator: str,
+        marker: str,
+        session_result: Optional[InquirerPySessionResult],
+        multiselect: bool,
+        marker_pl: str,
+    ) -> None:
+        self._pointer = pointer
+        self._separator = separator
+        self._marker = marker
+        self._marker_pl = marker_pl
+        super().__init__(
+            choices=choices,
+            default=default,
+            session_result=session_result,
+            multiselect=multiselect,
+        )
+
+    def _format_choices(self) -> None:
+        separator_count = 0
+        for index, choice in enumerate(self.choices):
+            if isinstance(choice["value"], Separator):
+                separator_count += 1
+                continue
+            choice["display_index"] = index + 1 - separator_count
+            choice["actual_index"] = index
+
+        if self.choices:
+            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 choice in self.choices:
+                    if isinstance(choice["value"], Separator):
+                        continue
+                    if choice["display_index"] == self._default:
+                        self.selected_choice_index = choice["actual_index"]
+                        break
+
+    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" % (str(choice["display_index"]), 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" % (str(choice["display_index"]), self._separator))
+            )
+            display_choices.append(("", choice["name"]))
+        else:
+            display_choices.append(("class:separator", choice["name"]))
+        return display_choices
+
+
+class RawlistPrompt(ListPrompt):
+    """Create a prompt that displays a list of choices with index number as shortcuts.
+
+    A wrapper class around :class:`~prompt_toolkit.application.Application`.
+
+    Each choice will have an index number infront of them with keybinding created for that index number.
+    Enables user to use number to jump to different choices using number.
+
+    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/rawlist: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.
+            For :class:`.RawlistPrompt` specifically, default value can also be value between 0-9.
+            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.
+        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.rawlist(message="Select one:", choices=[1, 2, 3]).execute()
+        >>> print(result)
+        1
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        choices: InquirerPyListChoices,
+        default: InquirerPyDefault = None,
+        separator: str = ") ",
+        style: Optional[InquirerPyStyle] = None,
+        vi_mode: bool = False,
+        qmark: str = "?",
+        amark: str = "?",
+        pointer: str = " ",
+        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:
+        self.content_control = InquirerPyRawlistControl(
+            choices=choices,
+            default=default,
+            pointer=pointer,
+            separator=separator,
+            marker=marker,
+            session_result=session_result,
+            multiselect=multiselect,
+            marker_pl=marker_pl,
+        )
+        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,
+            multiselect=multiselect,
+            validate=validate,
+            invalid_message=invalid_message,
+            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.
+
+        Check if fetched choices exceed the limit of 9, raise
+        InvalidArgument exception.
+        """
+
+        def keybinding_factory(choice):
+            @self.register_kb(str(choice["display_index"]))
+            def keybinding(_) -> None:
+                self.content_control.selected_choice_index = int(choice["actual_index"])
+
+            return keybinding
+
+        if self.content_control.choice_count >= 10:
+            raise InvalidArgument("rawlist argument choices cannot exceed length of 9")
+
+        for choice in self.content_control.choices:
+            if not isinstance(choice["value"], Separator):
+                keybinding_factory(choice)
+
+    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"] and self.content_control.choices:
+            display_message.append(
+                ("class:input", str(self.content_control.selection["display_index"]))
+            )
+        return display_message

InquirerPy/prompts/secret.py

@@ -0,0 +1,137 @@
+"""Module contains the class to create a secret prompt."""
+
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple
+
+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__ = ["SecretPrompt"]
+
+
+class SecretPrompt(InputPrompt):
+    """Create a text prompt which transforms the input to asterisks while typing.
+
+    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.
+        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.
+        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.secret(message="Password:").execute()
+        >>> print(f"Password: {result}")
+        Password: asdf123
+    """
+
+    def __init__(
+        self,
+        message: InquirerPyMessage,
+        style: Optional[InquirerPyStyle] = None,
+        default: InquirerPyDefault = "",
+        qmark: str = "?",
+        amark: str = "?",
+        instruction: str = "",
+        long_instruction: str = "",
+        vi_mode: 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,
+        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,
+            validate=validate,
+            invalid_message=invalid_message,
+            is_password=True,
+            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,
+        )
+
+    def _get_prompt_message(self) -> 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.
+        """
+        pre_answer = (
+            "class:instruction",
+            " %s " % self.instruction if self.instruction else " ",
+        )
+        post_answer = (
+            "class:answer",
+            (
+                ""
+                if not self.status["result"]
+                else " %s" % "".join(["*" for _ in self.status["result"]])
+            ),
+        )
+        return super()._get_prompt_message(pre_answer, post_answer)

InquirerPy/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.  The InquirerPy package uses inline types.

InquirerPy/resolver.py

@@ -0,0 +1,220 @@
+"""This module contains the classic entrypoint for creating prompts.
+
+A `PyInquirer <https://github.com/CITGuru/PyInquirer>`_ compatible entrypoint :func:`.prompt`.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from InquirerPy.exceptions import InvalidArgument, RequiredKeyNotFound
+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
+from InquirerPy.utils import (
+    InquirerPyKeybindings,
+    InquirerPyQuestions,
+    InquirerPySessionResult,
+    get_style,
+)
+
+__all__ = ["prompt", "prompt_async"]
+
+question_mapping = {
+    "confirm": ConfirmPrompt,
+    "filepath": FilePathPrompt,
+    "password": SecretPrompt,
+    "input": InputPrompt,
+    "list": ListPrompt,
+    "checkbox": CheckboxPrompt,
+    "rawlist": RawlistPrompt,
+    "expand": ExpandPrompt,
+    "fuzzy": FuzzyPrompt,
+    "number": NumberPrompt,
+}
+
+
+def _get_questions(questions: InquirerPyQuestions) -> List[Dict[str, Any]]:
+    """Process and validate questions.
+
+    Args:
+        questions: List of questions to create prompt.
+
+    Returns:
+        List of validated questions.
+    """
+    if isinstance(questions, dict):
+        questions = [questions]
+
+    if not isinstance(questions, list):
+        raise InvalidArgument("argument questions should be type of list or dictionary")
+
+    return questions
+
+
+def _get_question(
+    original_question: Dict[str, Any], result: InquirerPySessionResult, index: int
+) -> Tuple[Optional[Dict[str, Any]], str, Union[str, int], str]:
+    """Get information from individual question.
+
+    Args:
+        original_question: Original question dictionary.
+        result: Current prompt session result.
+        index: Question index.
+
+    Returns:
+        A tuple containing question information in the order of
+            question dictionary, type of question, name of question, message of question.
+    """
+    question = original_question.copy()
+    question_type = question.pop("type")
+    question_name = question.pop("name", index)
+    message = question.pop("message")
+    question_when = question.pop("when", None)
+    if question_when and not question_when(result):
+        result[question_name] = None
+        question = None
+    return question, question_type, question_name, message
+
+
+async def prompt_async(
+    questions: InquirerPyQuestions,
+    style: Optional[Dict[str, str]] = None,
+    vi_mode: bool = False,
+    raise_keyboard_interrupt: bool = True,
+    keybindings: Optional[InquirerPyKeybindings] = None,
+    style_override: bool = True,
+) -> InquirerPySessionResult:
+    """Classic syntax entrypoint to create a prompt session via asynchronous method.
+
+    Refer to :func:`InquirerPy.resolver.prompt` for detailed documentations.
+    """
+    result: InquirerPySessionResult = {}
+    if not keybindings:
+        keybindings = {}
+
+    questions = _get_questions(questions=questions)
+    question_style = get_style(style, style_override)
+
+    for index, original_question in enumerate(questions):
+        try:
+            question, question_type, question_name, message = _get_question(
+                original_question=original_question, result=result, index=index
+            )
+            if question is None:
+                continue
+            args = {
+                "message": message,
+                "style": question_style,
+                "vi_mode": vi_mode,
+                "raise_keyboard_interrupt": raise_keyboard_interrupt,
+                "session_result": result,
+                "keybindings": {**keybindings, **question.pop("keybindings", {})},
+            }
+            result[question_name] = await question_mapping[question_type](
+                **args, **question
+            ).execute_async()
+        except KeyError:
+            raise RequiredKeyNotFound
+
+    return result
+
+
+def prompt(
+    questions: InquirerPyQuestions,
+    style: Optional[Dict[str, str]] = None,
+    vi_mode: bool = False,
+    raise_keyboard_interrupt: bool = True,
+    keybindings: Optional[InquirerPyKeybindings] = None,
+    style_override: bool = True,
+) -> InquirerPySessionResult:
+    """Classic syntax entrypoint to create a prompt session.
+
+    Resolve user provided list of questions, display prompts and get the results.
+
+    Args:
+        questions: A list of :ref:`pages/prompt:question` to ask. Refer to documentation for more info.
+        style: A :class:`dict` containing the style specification for the prompt. Refer to :ref:`pages/style:Style` for more info.
+        vi_mode: Use vim keybindings for the prompt instead of the default emacs keybindings.
+            Refer to :ref:`pages/kb:Keybindings` for more info.
+        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.
+        keybindings: List of custom :ref:`pages/kb:Keybindings` to apply. Refer to documentation for more info.
+        style_override: Override all default styles. When providing any style customisation, all default styles are removed when this is True.
+
+    Returns:
+        A dictionary containing all of the question answers. The key is the name of the question and the value is the
+        user answer. If the `name` key is not present as part of the question, then the question index will be used
+        as the key.
+
+    Raises:
+        RequiredKeyNotFound: When the question is missing required keys.
+        InvalidArgument: When the provided `questions` argument is not a type of :class:`list` nor :class:`dictionary`.
+
+    Examples:
+        >>> from InquirerPy import prompt
+        >>> from InquirerPy.validator import NumberValidator
+        >>> questions = [
+        ...     {
+        ...         "type": "input",
+        ...         "message": "Enter your age:",
+        ...         "validate": NumberValidator(),
+        ...         "invalid_message": "Input should be number.",
+        ...         "default": "18",
+        ...         "name": "age",
+        ...         "filter": lambda result: int(result),
+        ...         "transformer": lambda result: "Adult" if int(result) >= 18 else "Youth",
+        ...     },
+        ...     {
+        ...         "type": "rawlist",
+        ...         "message": "What drinks would you like to buy:",
+        ...         "default": 2,
+        ...         "choices": lambda result: ["Soda", "Cidr", "Water", "Milk"]
+        ...         if result["age"] < 18
+        ...         else ["Wine", "Beer"],
+        ...         "name": "drink",
+        ...     },
+        ...     {
+        ...         "type": "list",
+        ...         "message": "Would you like a bag:",
+        ...         "choices": ["Yes", "No"],
+        ...         "when": lambda result: result["drink"] in {"Wine", "Beer"},
+        ...     },
+        ...     {"type": "confirm", "message": "Confirm?", "default": True},
+        ... ]
+        >>> result = prompt(questions=questions)
+    """
+    result: InquirerPySessionResult = {}
+    if not keybindings:
+        keybindings = {}
+
+    questions = _get_questions(questions=questions)
+    question_style = get_style(style, style_override)
+
+    for index, original_question in enumerate(questions):
+        try:
+            question, question_type, question_name, message = _get_question(
+                original_question=original_question, result=result, index=index
+            )
+            if question is None:
+                continue
+            args = {
+                "message": message,
+                "style": question_style,
+                "vi_mode": vi_mode,
+                "raise_keyboard_interrupt": raise_keyboard_interrupt,
+                "session_result": result,
+                "keybindings": {**keybindings, **question.pop("keybindings", {})},
+            }
+            result[question_name] = question_mapping[question_type](
+                **args, **question
+            ).execute()
+        except KeyError:
+            raise RequiredKeyNotFound
+
+    return result

InquirerPy/separator.py

@@ -0,0 +1,23 @@
+"""Module contains the :class:`.Separator` class."""
+
+
+class Separator:
+    """A non selectable choice that can be used as part of the choices argument in list type prompts.
+
+    It can be used to create some visual separations between choices in list type prompts.
+
+    Args:
+        line: Content to display as the separator.
+
+    Example:
+        >>> from InquirerPy import inquirer
+        >>> choices = [1, 2, Separator(), 3]
+        >>> inquirer.select(message="", choices=choices)
+    """
+
+    def __init__(self, line: str = 15 * "-") -> None:
+        self._line = line
+
+    def __str__(self) -> str:
+        """Create string representation of `Separator`."""
+        return self._line