Questionary

https://questionary.readthedocs.io/en/stable
Admin
Questionary is a Python library for effortlessly building pretty command line interfaces by enabling...
Tokens:31,083
Snippets:267
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Output Format for form()

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Example of the printed output format when using form().

```python
{'first': True, 'second': 'item2'}
```

--------------------------------

### Multiple Questions Form

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Example of creating a form with multiple questions.

```python
answers = questionary.form(
    first = questionary.confirm("Would you like the next question?", default=True),
    second = questionary.select("Select item", choices=["item1", "item2", "item3"])
).ask()
```

--------------------------------

### Single Question Prompt

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Example of asking a single password question.

```python
questionary.password("What's your secret?").ask()
```

--------------------------------

### Asking Multiple Questions with form()

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Example of using the form() function to ask a collection of questions.

```python
import questionary

answers = questionary.form(
    first = questionary.confirm("Would you like the next question?", default=True),
    second = questionary.select("Select item", choices=["item1", "item2", "item3"])
).ask()

print(answers)
```

--------------------------------

### Asking Multiple Questions with prompt()

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Example of using the prompt() function with a list of question dictionaries.

```python
import questionary

questions = [
  {
    "type": "confirm",
    "name": "first",
    "message": "Would you like the next question?",
    "default": True,
  },
  {
    "type": "select",
    "name": "second",
    "message": "Select item",
    "choices": ["item1", "item2", "item3"],
  },
]

questionary.prompt(questions)
```

--------------------------------

### Select example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/select.html

This is just a really basic example, the prompt can be customised using the parameters.

```python
import questionary

questionary.select(
    "What do you want to do?",
    choices=[
        "Order a pizza",
        "Make a reservation",
        "Ask for opening hours"
    ]
).ask()
```

--------------------------------

### Installing Questionary

Source: https://questionary.readthedocs.io/en/stable/index.html

This command shows how to install the Questionary library using pip.

```bash
pip install questionary

```

--------------------------------

### Install recording tools

Source: https://questionary.readthedocs.io/en/stable/pages/contributors.html

Installs asciinema and asciicast2gif for creating command line recordings.

```bash
$ brew install asciinema
$ npm install --global asciicast2gif
```

--------------------------------

### Asking a Single Question

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Demonstrates prompting the user for an answer to a created question.

```python
answer = question.ask()
```

--------------------------------

### Creating a Single Question

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Demonstrates creating a text question object.

```python
import questionary

question = questionary.text("What's your first name")
```

--------------------------------

### Install Questionary using pip

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

To install Questionary, simply run this command in your terminal of choice:

```bash
$ pip install questionary

```

--------------------------------

### Install Questionary in editable mode

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

To install Questionary and its dependencies in editable mode, execute

```bash
$ make install

```

--------------------------------

### Install Poetry

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

Questionary uses Poetry for packaging and dependency management. If you want to build Questionary from source, you must install Poetry first:

```bash
$ curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python3

```

--------------------------------

### Download the Questionary tarball

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

Or, download the tarball:

```bash
$ curl -OL https://github.com/tmbo/questionary/tarball/master

```

--------------------------------

### Password Prompt Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/password.html

Demonstrates how to use the password prompt to get secret input from the user, which is masked with asterisks.

```python
import questionary

questionary.password("What's your secret?").ask()
```

--------------------------------

### Concatenated Single Question

Source: https://questionary.readthedocs.io/en/stable/pages/quickstart.html

Shows creating and asking a text question in a single line.

```python
import questionary

answer = questionary.text("What's your first name").ask()
```

--------------------------------

### Checkbox Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/checkbox.html

Example of how to use the checkbox prompt to select multiple items.

```python
import questionary

questionary.checkbox(
   'Select toppings',
   choices=[
       "Cheese",
       "Tomato",
       "Pineapple",
   ]).ask()
```

--------------------------------

### Start command line recording

Source: https://questionary.readthedocs.io/en/stable/pages/contributors.html

Initiates a new terminal session recording.

```bash
$ asciinema rec
```

--------------------------------

### Clone the Questionary repository

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

You can either clone the public repository:

```bash
$ git clone git@github.com:tmbo/questionary.git

```

--------------------------------

### Example Output Dictionary

Source: https://questionary.readthedocs.io/en/stable/pages/advanced.html

The structure of the dictionary returned by the prompt function.

```json
{"phone": "0123123", "continue": False}.
```

--------------------------------

### Download the Questionary zipball (Windows)

Source: https://questionary.readthedocs.io/en/stable/pages/installation.html

If you are using windows, you can also download a zip instead:

```bash
$ curl -OL https://github.com/tmbo/questionary/zipball/master

```

--------------------------------

### Path Prompt Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/path.html

This example demonstrates how to use the questionary.path prompt to ask for a file or directory path with autocompletion.

```python
>>> import questionary
>>> questionary.path(
>>>    "What's the path to the projects version file?"
>>> ).ask()
? What's the path to the projects version file? ./pyproject.toml
'./pyproject.toml'
```

--------------------------------

### Basic Checkbox Selection

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

A simple example demonstrating how to initialize a checkbox prompt with a list of choices and execute it using .ask().

```python
>>> import questionary
>>> questionary.checkbox(
...    'Select toppings',
...    choices=[
...        "Cheese",
...        "Tomato",
...        "Pineapple",
...    ]).ask()
? Select toppings done (2 selections)
['Cheese', 'Pineapple']
```

--------------------------------

### Confirm Prompt Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/confirm.html

This example demonstrates how to use the confirm prompt to ask a yes-or-no question. The user's input is captured and the boolean result is returned.

```python
import questionary

questionary.confirm("Are you amazed?").ask()
```

--------------------------------

### Text Prompt Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/text.html

Example of how to use the text prompt to ask for the user's first name.

```python
import questionary

questionary.text("What's your first name?").ask()
```

--------------------------------

### Example Usage of print_formatted_text

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/common.html

Demonstrates how to use the `print_formatted_text` function to display styled messages.

```python
import questionary
questionary.print("Hello World 🦄", style="bold italic fg:darkred")
```

--------------------------------

### Autocomplete Function Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/autocomplete.html

Example usage of the autocomplete function to prompt the user for input with autocompletion suggestions.

```python
import questionary



def autocomplete(
    message: str,
    choices: List[str],
    default: str = "",
    qmark: str = DEFAULT_QUESTION_PREFIX,
    completer: Optional[Completer] = None,
    meta_information: Optional[Dict[str, Any]] = None,
    ignore_case: bool = True,
    match_middle: bool = True,
    complete_style: CompleteStyle = CompleteStyle.COLUMN,
    validate: Any = None,
    style: Optional[Style] = None,
    **kwargs: Any,
) -> Question:
    """Prompt the user to enter a message with autocomplete help.

    Example:
        >>> import questionary
        >>> questionary.autocomplete(
        ...    'Choose ant specie',
        ...    choices=[
        ...         'Camponotus pennsylvanicus',
        ...         'Linepithema humile',
        ...         'Eciton burchellii',
        ...         "Atta colombica",
        ...         'Polyergus lucidus',
        ...         'Polyergus rufescens',
        ...    ]).ask()
        ? Choose ant specie Atta colombica
        'Atta colombica'

    .. image:: ../images/autocomplete.gif

    This is just a really basic example, the prompt can be customised using the
    parameters.


    Args:
        message: Question text

        choices: Items shown in the selection, this contains items as strings

        default: Default return value (single value).

        qmark: Question prefix displayed in front of the question.
               By default this is a ``?``

        completer: A prompt_toolkit :class:`prompt_toolkit.completion.Completion`
                   implementation. If not set, a questionary completer implementation

```

--------------------------------

### Example

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/press_any_key_to_continue.html

Wait until user presses any key to continue.

```python
>>> import questionary
>>> questionary.press_any_key_to_continue().ask()
 Press any key to continue...
''
```

--------------------------------

### Configure development environment

Source: https://questionary.readthedocs.io/en/stable/pages/contributors.html

Initializes the development environment using the project's makefile.

```bash
make develop
```

--------------------------------

### Basic Raw Select Usage

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Demonstrates a simple rawselect prompt where the user chooses from a list of string options.

```python
>>> import questionary
>>> questionary.rawselect(
...     "What do you want to do?",
...     choices=[
...         "Order a pizza",
...         "Make a reservation",
...         "Ask for opening hours"
...     ]).ask()
? What do you want to do? Order a pizza
'Order a pizza'
```

--------------------------------

### Creating your first prompt

Source: https://questionary.readthedocs.io/en/stable/index.html

This code snippet demonstrates how to create a simple text input prompt using the Questionary library.

```python
import questionary

first_name = questionary.text("What's your first name").ask()

```

--------------------------------

### Run unit tests

Source: https://questionary.readthedocs.io/en/stable/pages/contributors.html

Executes the project's test suite to verify functionality.

```bash
$ make test
```

--------------------------------

### questionary.press_any_key_to_continue(style=None, **kwargs)

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Pauses execution and waits for the user to press any key to continue.

```APIDOC
## questionary.press_any_key_to_continue(style=None, **kwargs)

### Description
Waits until the user presses any key to continue. Returns a Question instance that can be prompted using .ask().

### Parameters
- **message** (Optional[str]) - Optional - The question text to display. Defaults to "Press any key to continue...".
- **style** (Optional[Style]) - Optional - A custom color and style for the question parts.
- **kwargs** (Any) - Optional - Additional arguments.

### Returns
Question instance, ready to be prompted (using .ask()).
```

--------------------------------

### Text Prompt Implementation

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/text.html

The implementation of the text prompt function, including style merging, lexer setup, validator building, instruction handling, token generation, and prompt session creation.

```python
merged_style = merge_styles_default([style])
lexer = lexer or SimpleLexer("class:answer")
validator = build_validator(validate)

if instruction is None and multiline:
    instruction = INSTRUCTION_MULTILINE

def get_prompt_tokens() -> List[Tuple[str, str]]:
    result = [("class:qmark", qmark), ("class:question", " {} ".format(message))]
    if instruction:
        result.append(("class:instruction", " {} ".format(instruction)))
    return result

p: PromptSession = PromptSession(
    get_prompt_tokens,
    style=merged_style,
    validator=validator,
    lexer=lexer,
    multiline=multiline,
    **kwargs,
)
p.default_buffer.reset(Document(default))
```

--------------------------------

### Define Questions via Dictionary

Source: https://questionary.readthedocs.io/en/stable/pages/advanced.html

Basic implementation of a prompt sequence using a list of configuration dictionaries.

```python
from questionary import prompt

questions = [
    {
        'type': 'text',
        'name': 'phone',
        'message': "What's your phone number",
    },
    {
        'type': 'confirm',
        'message': 'Do you want to continue?',
        'name': 'continue',
        'default': True,
    }
]

answers = prompt(questions)
```

--------------------------------

### questionary.print(text, style=None, **kwargs)

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Prints formatted text to the console using prompt toolkit style strings.

```APIDOC
## questionary.print(text, style=None, **kwargs)

### Description
Prints formatted text to the console. This helper allows for styling messages using prompt toolkit style strings.

### Parameters
- **text** (str) - Required - The text to be printed.
- **style** (Optional[str]) - Optional - Style used for printing, based on prompt toolkit style strings.
- **kwargs** (Any) - Optional - Additional arguments.

### Return Type
None
```

--------------------------------

### Print formatted text with Questionary

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Uses prompt toolkit style strings to apply formatting to console output.

```python
>>> import questionary
>>> questionary.print("Hello World 🦄", style="bold italic fg:darkred")
Hello World 🦄
```

--------------------------------

### questionary.select

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Creates a list of items for the user to select a single option from. Returns a Question instance that can be executed with .ask().

```APIDOC
## questionary.select(message, choices, default=None, qmark='?', pointer='»', style=None, use_shortcuts=False, use_arrow_keys=True, use_indicator=False, use_jk_keys=True, use_emacs_keys=True, show_selected=False, instruction=None, **kwargs)

### Description
A list of items to select one option from. The user can pick one option and confirm it.

### Parameters
- **message** (str) - Required - Question text.
- **choices** (Sequence[Union[str, Choice, Dict[str, Any]]]) - Required - Items shown in the selection.
- **default** (Union[str, Choice, Dict[str, Any], None]) - Optional - Initial pointer position.
- **qmark** (str) - Optional - Question prefix.
- **pointer** (Optional[str]) - Optional - Pointer symbol for highlighted element.
- **instruction** (Optional[str]) - Optional - Hint on how to navigate.
- **style** (Optional[Style]) - Optional - Custom color and style.
- **use_indicator** (bool) - Optional - Enable indicator in front of the list.
- **use_shortcuts** (bool) - Optional - Allow selection using shortcuts.
- **use_arrow_keys** (bool) - Optional - Allow selection using arrow keys.
- **use_jk_keys** (bool) - Optional - Allow selection using j/k keys.
- **use_emacs_keys** (bool) - Optional - Allow selection using Ctrl+N/Ctrl+P keys.
- **show_selected** (bool) - Optional - Display current selection at bottom of list.

### Returns
- **Question** - Instance ready to be prompted using .ask().
```

--------------------------------

### questionary.path

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Prompts the user for a file or directory path with built-in autocompletion.

```APIDOC
## questionary.path(message, default='', qmark='?', validate=None, completer=None, style=None, only_directories=False, get_paths=None, file_filter=None, complete_style=CompleteStyle.MULTI_COLUMN, **kwargs)

### Description
A text input for a file or directory path with autocompletion enabled.

### Parameters
- **message** (str) - Required - Question text.
- **default** (str) - Optional - Default return value.
- **qmark** (str) - Optional - Question prefix, defaults to '?'.
- **complete_style** (CompleteStyle) - Optional - Style of the autocomplete menu.
- **validate** (Any) - Optional - Validator function or class.
- **completer** (Completer) - Optional - Custom completer instance.
- **style** (Style) - Optional - Custom color and style configuration.
- **only_directories** (bool) - Optional - Only show directories in completion.
- **get_paths** (Callable) - Optional - Callable to generate paths for suggestions.
- **file_filter** (Callable) - Optional - Callable to filter suggested paths.

### Returns
- **Question** - A question instance ready to be prompted using `.ask()`.
```

--------------------------------

### Create a Selection Prompt

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Allows the user to select a single option from a provided list of choices.

```python
>>> import questionary
>>> questionary.select(
...     "What do you want to do?",
...     choices=[
...         "Order a pizza",
...         "Make a reservation",
...         "Ask for opening hours"
...     ]).ask()
? What do you want to do? Order a pizza
'Order a pizza'
```

--------------------------------

### Define a custom style object

Source: https://questionary.readthedocs.io/en/stable/pages/advanced.html

Create a Style instance mapping token identifiers to color and formatting strings.

```python
from questionary import Style

custom_style_fancy = Style([
    ('qmark', 'fg:#673ab7 bold'),       # token in front of the question
    ('question', 'bold'),               # question text
    ('answer', 'fg:#f44336 bold'),      # submitted answer text behind the question
    ('pointer', 'fg:#673ab7 bold'),     # pointer used in select and checkbox prompts
    ('highlighted', 'fg:#673ab7 bold'), # pointed-at choice in select and checkbox prompts
    ('selected', 'fg:#cc5454'),         # style for a selected item of a checkbox
    ('separator', 'fg:#cc5454'),        # separator in lists
    ('instruction', ''),                # user instructions for select, rawselect, checkbox
    ('text', ''),                       # plain text
    ('disabled', 'fg:#858585 italic')   # disabled choices for select and checkbox prompts
])
```

--------------------------------

### questionary.rawselect

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Prompts the user to select one item from a list of choices using shortcuts.

```APIDOC
## questionary.rawselect(message, choices, default=None, qmark='?', pointer='»', style=None, **kwargs)

### Description
Ask the user to select one item from a list of choices using shortcuts. The user can only select one option.

### Parameters
- **message** (str) - Required - Question text.
- **choices** (Sequence[Union[str, Choice, Dict[str, Any]]]) - Required - Items shown in the selection. Can contain Choice, Separator, or simple strings.
- **default** (Optional[str]) - Optional - Default return value.
- **qmark** (str) - Optional - Question prefix displayed in front of the question (default: '?').
- **pointer** (Optional[str]) - Optional - Pointer symbol in front of the currently highlighted element (default: '»').
- **style** (Optional[Style]) - Optional - Custom color and style for the question parts.
- **kwargs** (Any) - Optional - Additional arguments.

### Returns
- **Question** - A Question instance, ready to be prompted using .ask().

### Example
```python
import questionary
questionary.rawselect(
    "What do you want to do?",
    choices=[
        "Order a pizza",
        "Make a reservation",
        "Ask for opening hours"
    ]).ask()
```
```

--------------------------------

### questionary.prompts.select

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/select.html

Source code for the questionary.prompts.select module.

```python
import collections

from prompt_toolkit.filters import Condition
from prompt_toolkit.layout.containers import HSplit, Window, VSplit
from prompt_toolkit.layout.controls import FormattedTextControl, Label
from prompt_toolkit.layout.dimension import Dimension
from prompt_toolkit.layout.layout import Layout
from prompt_toolkit.shortcuts import print_formatted_text

from questionary.constants import DEFAULT_CHOICE_STYLE, DEFAULT_STYLE
from questionary.prompts.common import Choice, CommonPrompt


class Select(CommonPrompt):
    """Select prompt.

    :param message: questionary message
    :param choices: list of choices
    :param default: default value
    :param style: questionary style
    :param validate: validation function
    :param instruction: instruction message
    :param auto_enter: auto enter when only one choice
    :param use_shortcuts: use shortcuts for choices
    """

    def __init__(
        self,
        message,
        choices,
        default=None,
        style=None,
        validate=None,
        instruction=None,
        auto_enter=True,
        use_shortcuts=False,
    ):
        self.auto_enter = auto_enter
        self.use_shortcuts = use_shortcuts
        self.choices = choices
        self.message = message
        self.default = default
        self.style = style if style else DEFAULT_STYLE
        self.validate = validate
        self.instruction = instruction
        self._choices_cache = None
        self._choices_count = 0
        self._current_choice_index = 0
        self._filter_text = ""
        self._filter_timeout = None
        self._choices_filtered = False

    @property
    def _choices(self):
        if self._choices_cache is None:
            self._choices_cache = self._build_choices(self.choices)
        return self._choices_cache

    def _build_choices(self, choices):
        """Build choices from a list of strings or Choice objects.

        :param choices: list of choices
        :return: list of Choice objects
        """
        result = []
        for i, choice in enumerate(choices):
            if isinstance(choice, Choice):
                result.append(choice)
            else:
                result.append(Choice(choice, name=choice))
        self._choices_count = len(result)
        return result

    def _get_choice_text(self, choice, index, filter_text):
        """Get the text of a choice, with filtering applied.

        :param choice: Choice object
        :param index: index of the choice
        :param filter_text: filter text
        :return: formatted text of the choice
        """
        shortcut = " ({})".format(choice.shortcut) if choice.shortcut else ""
        if filter_text and filter_text.lower() in choice.name.lower():
            return "{} {}".format(choice.name, shortcut)
        elif filter_text:
            return "{} {}".format(choice.name, shortcut)
        else:
            return "{} {}".format(choice.name, shortcut)

    def _get_choice_style(self, choice, index, filter_text):
        """Get the style of a choice.

        :param choice: Choice object
        :param index: index of the choice
        :param filter_text: filter text
        :return: style of the choice
        """
        if choice.style:
            return choice.style
        elif self._current_choice_index == index and not filter_text:
            return self.style("selected")
        else:
            return self.style("default")

    def _get_filtered_choices(self, filter_text):
        """Get filtered choices.

        :param filter_text: filter text
        :return: list of filtered choices
        """
        if not filter_text:
            return self._choices

        filtered = []
        for choice in self._choices:
            if filter_text.lower() in choice.name.lower():
                filtered.append(choice)
        return filtered

    def _get_layout(self):
        """Get the layout of the prompt.

        :return: Layout object
        """
        return Layout(
            HSplit([
                Window(
                    content=Label(
                        f"{self.message} "
                    ),
                    height=Dimension(unit=1),
                    wrap=True,
                ),
                Window(
                    content=FormattedTextControl(
                        self._get_choice_text_formatted,
                        key_bindings=self.key_bindings,
                    ),
                    wrap=True,
                ),
                Window(
                    height=Dimension(unit=1),
                    content=FormattedTextControl(self._get_instruction_text_formatted),
                ),
            ])
        )

    def _get_instruction_text_formatted(self):
        """Get the instruction text formatted.

        :return: formatted instruction text
        """
        if self.instruction:
            return self.style(self.instruction)
        return ""

    def _get_choice_text_formatted(self):
        """
        Get the choice text formatted.

        :return: formatted choice text
        """
        choices = self._get_filtered_choices(self._filter_text)
        lines = []
        for i, choice in enumerate(choices):
            text = self._get_choice_text(choice, i, self._filter_text)
            style = self._get_choice_style(choice, i, self._filter_text)
            lines.append((style, text))
            lines.append(("", "\n"))

        return lines

    def _handle_key_press(self, event):
        """Handle key press event.

        :param event: key press event
        """
        if event.key == "escape":
            self.app.exit()
        elif event.key == "c-c":
            self.app.exit()
        elif event.key == "enter":
            self._select_choice()
        elif event.key == "up":
            self._previous_choice()
        elif event.key == "down":
            self._next_choice()
        elif event.key == "right":
            self._next_choice()
        elif event.key == "left":
            self._previous_choice()
        elif event.key == "pageup":
            self._page_up_choice()
        elif event.key == "pagedown":
            self._page_down_choice()
        elif event.key == "home":
            self._first_choice()
        elif event.key == "end":
            self._last_choice()
        elif event.key == "tab":
            self._toggle_filter_mode()
        elif event.key == "backspace":
            self._backspace_filter()
        else:
            self._add_filter(event.key)

    def _add_filter(self, key):
        """Add character to filter.

        :param key: key pressed
        """
        self._filter_text += key
        self._choices_filtered = True

    def _backspace_filter(self):
        """Remove last character from filter.
        """
        self._filter_text = self._filter_text[:-1]
        self._choices_filtered = True

    def _toggle_filter_mode(self):
        """Toggle filter mode.
        """
        self._filter_text = ""
        self._choices_filtered = False

    def _select_choice(self):
        """Select the current choice.
        """
        if self._choices_filtered:
            choices = self._get_filtered_choices(self._filter_text)
            if len(choices) == 1:
                self.selected = choices[0].value
                self.app.exit()
        else:
            self.selected = self._choices[self._current_choice_index].value
            self.app.exit()

    def _next_choice(self):
        """Move to the next choice.
        """
        self._current_choice_index = (
            self._current_choice_index + 1
        ) % self._choices_count

    def _previous_choice(self):
        """Move to the previous choice.
        """
        self._current_choice_index = (
            self._current_choice_index - 1
        ) % self._choices_count

    def _page_up_choice(self):
        """Move to the previous page of choices.
        """
        self._current_choice_index = (
            self._current_choice_index - 10
        ) % self._choices_count

    def _page_down_choice(self):
        """Move to the next page of choices.
        """
        self._current_choice_index = (
            self._current_choice_index + 10
        ) % self._choices_count

    def _first_choice(self):
        """Move to the first choice.
        """
        self._current_choice_index = 0

    def _last_choice(self):
        """Move to the last choice.
        """
        self._current_choice_index = self._choices_count - 1

    def _get_key_bindings(self):
        """Get key bindings.

        :return: KeyBindings object
        """
        from prompt_toolkit.key_binding import KeyBindings

        kb = KeyBindings()

        @kb.add("escape", eager=True)
        @kb.add("c-c", eager=True)
        def _(event):
            self.app.exit()

        @kb.add("enter", eager=True)
        def _(event):
            self._select_choice()

        @kb.add("up", eager=True)
        @kb.add("k", eager=True)
        def _(event):
            self._previous_choice()

        @kb.add("down", eager=True)
        @kb.add("j", eager=True)
        def _(event):
            self._next_choice()

        @kb.add("right", eager=True)
        @kb.add("l", eager=True)
        def _(event):
            self._next_choice()

        @kb.add("left", eager=True)
        @kb.add("h", eager=True)
        def _(event):
            self._previous_choice()

        @kb.add("pageup", eager=True)
        def _(event):
            self._page_up_choice()

        @kb.add("pagedown", eager=True)
        def _(event):
            self._page_down_choice()

        @kb.add("home", eager=True)
        def _(event):
            self._first_choice()

        @kb.add("end", eager=True)
        def _(event):
            self._last_choice()

        @kb.add("tab", eager=True)
        def _(event):
            self._toggle_filter_mode()

        @kb.add("backspace", eager=True)
        def _(event):
            self._backspace_filter()

        @kb.add(filter=Condition(lambda: self._choices_filtered), eager=True)
        def _(event):
            self._add_filter(event.char)

        return kb

    def ask(self):
        """Ask the question.

        :return: selected choice value
        """
        self.key_bindings = self._get_key_bindings()
        self.app.run_ளுக்காக(self._get_layout(), set_exception_handler=True)
        return self.selected

```

--------------------------------

### prompt(questions, answers=None, patch_stdout=False, true_color=False, color_depth=None, type=None, filter=None, name=None, when=None, default=None, **kwargs)

Source: https://questionary.readthedocs.io/en/stable/pages/api_reference.html

The primary function to execute a series of questions and collect user input.

```APIDOC
## prompt(questions, answers=None, patch_stdout=False, true_color=False, color_depth=None, type=None, filter=None, name=None, when=None, default=None, **kwargs)

### Description
Executes a series of questions and returns a dictionary containing the user's answers.

### Parameters
- **questions** (Union[Dict[str, Any], Iterable[Mapping[str, Any]]]) - Required - A list of question configurations.
- **answers** (Optional[Mapping[str, Any]]) - Optional - Default answers to pre-populate.
- **patch_stdout** (bool) - Optional - Ensures prompt renders correctly if other threads print to stdout.
- **true_color** (bool) - Optional - Enables true color output.
- **color_depth** (Any) - Optional - Specifies color depth; ignored if true_color is set.
- **type** (Any) - Optional - Default type for question configs.
- **filter** (Any) - Optional - Default filter function for question configs.
- **name** (Any) - Optional - Default name for question configs.
- **when** (Any) - Optional - Default conditional function for question configs.
- **default** (Any) - Optional - Default value for question configs.
- **kwargs** (Any) - Optional - Additional options passed to every question.

### Returns
- **Dict[str, Any]** - A dictionary containing the collected answers.

### Raises
- **KeyboardInterrupt** - Raised when the user interrupts the process.
```

--------------------------------

### Path Prompt Implementation

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/path.html

This is the core implementation of the path prompt, including custom key bindings for navigation and completion.

```python
default: str = "",
qmark: str = DEFAULT_QUESTION_PREFIX,
validate: Any = None,
completer: Optional[Completer] = None,
style: Optional[Style] = None,
only_directories: bool = False,
get_paths: Optional[Callable[[], List[str]]] = None,
file_filter: Optional[Callable[[str], bool]] = None,
complete_style: CompleteStyle = CompleteStyle.MULTI_COLUMN,
**kwargs: Any,
) -> Question:
    """A text input for a file or directory path with autocompletion enabled.

    Example:
        >>> import questionary
        >>> questionary.path(
        >>>    "What's the path to the projects version file?"
        >>> ).ask()
        ? What's the path to the projects version file? ./pyproject.toml
        './pyproject.toml'

    .. image:: ../images/path.gif

    This is just a really basic example, the prompt can be customized using the
    parameters.

    Args:
        message: Question text.

        default: Default return value (single value).

        qmark: Question prefix displayed in front of the question.
               By default this is a ``?``.

        complete_style: How autocomplete menu would be shown, it could be ``COLUMN``
                        ``MULTI_COLUMN`` or ``READLINE_LIKE`` from
                        :class:`prompt_toolkit.shortcuts.CompleteStyle`.

        validate: Require the entered value to pass a validation. The
                  value can not be submitted until the validator accepts
                  it (e.g. to check minimum password length).

                  This can either be a function accepting the input and
                  returning a boolean, or an class reference to a
                  subclass of the prompt toolkit Validator class.

        completer: A custom completer to use in the prompt. For more information,
                   see `this <https://python-prompt-toolkit.readthedocs.io/en/master/pages/asking_for_input.html#a-custom-completer>`_.

        style: A custom color and style for the question parts. You can
               configure colors as well as font types for different elements.

        only_directories: Only show directories in auto completion. This option
                          does not do anything if a custom ``completer`` is
                          passed.

        get_paths: Set a callable to generate paths to traverse for suggestions. This option
                   does not do anything if a custom ``completer`` is
                   passed.

        file_filter: Optional callable to filter suggested paths. Only paths
                     where the passed callable evaluates to ``True`` will show up in
                     the suggested paths. This does not validate the typed path, e.g.
                     it is still possible for the user to enter a path manually, even
                     though this filter evaluates to ``False``. If in addition to
                     filtering suggestions you also want to validate the result, use
                     ``validate`` in combination with the ``file_filter``.

    Returns:
        :class:`Question`: Question instance, ready to be prompted (using ``.ask()``).
    """  # noqa: W505, E501
    merged_style = merge_styles_default([style])

    def get_prompt_tokens() -> List[Tuple[str, str]]:
        return [("class:qmark", qmark), ("class:question", " {} ".format(message))]

    validator = build_validator(validate)

    completer = completer or GreatUXPathCompleter(
        get_paths=get_paths,
        only_directories=only_directories,
        file_filter=file_filter,
        expanduser=True,
    )

    bindings = KeyBindings()

    @bindings.add(Keys.ControlM, eager=True)
    def set_answer(event: KeyPressEvent):
        if event.current_buffer.complete_state is not None:
            event.current_buffer.complete_state = None
        elif event.app.current_buffer.validate(set_cursor=True):
            # When the validation succeeded, accept the input.
            result_path = event.app.current_buffer.document.text
            if result_path.endswith(os.path.sep):
                result_path = result_path[:-1]

            event.app.exit(result=result_path)
            event.app.current_buffer.append_to_history()

    @bindings.add(os.path.sep, eager=True)
    def next_segment(event: KeyPressEvent):
        b = event.app.current_buffer

        if b.complete_state:
            b.complete_state = None

        current_path = b.document.text
        if not current_path.endswith(os.path.sep):
            b.insert_text(os.path.sep)

        b.start_completion(select_first=False)

    p: PromptSession = PromptSession(
        get_prompt_tokens,
        lexer=SimpleLexer("class:answer"),
        style=merged_style,
        completer=completer,
        validator=validator,
        complete_style=complete_style,
        key_bindings=bindings,
        **kwargs,
    )
    p.default_buffer.reset(Document(default))
```

--------------------------------

### Pause execution with press_any_key_to_continue

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Blocks execution until the user presses a key, returning a Question instance that must be invoked with .ask().

```python
>>> import questionary
>>> questionary.press_any_key_to_continue().ask()
 Press any key to continue...
''
```

--------------------------------

### questionary.checkbox

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Creates a multiselect prompt for the user to select items from a list.

```APIDOC
## questionary.checkbox(message, choices, ...)

### Description
Ask the user to select from a list of items. This is a multiselect prompt where the user can choose one, none, or many of the items.

### Parameters
- **message** (str) - Required - Question text
- **choices** (Sequence[Union[str, Choice, Dict[str, Any]]]) - Required - Items shown in the selection
- **default** (Optional[str]) - Optional - Default return value
- **validate** (Callable[[List[str]], Union[bool, str]]) - Optional - Function to validate the selection
- **qmark** (str) - Optional - Question prefix (default: '?')
- **pointer** (Optional[str]) - Optional - Pointer symbol (default: '»')
- **style** (Optional[Style]) - Optional - Custom color and style
- **initial_choice** (Union[str, Choice, Dict[str, Any], None]) - Optional - Initial pointer position
- **use_arrow_keys** (bool) - Optional - Enable arrow key navigation
- **use_jk_keys** (bool) - Optional - Enable j/k key navigation
- **use_emacs_keys** (bool) - Optional - Enable Ctrl+N/P navigation
- **instruction** (Optional[str]) - Optional - Navigation instruction message

### Returns
- **Question** - A question instance ready to be prompted using .ask()
```

--------------------------------

### Choice Initialization Helper

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/common.html

Internal helper method to initialize the list of choices, converting input formats and setting the initial pointed-at choice.

```python
    def _init_choices(
        self,
        choices: Sequence[Union[str, Choice, Dict[str, Any]]],
        pointed_at: Optional[int],
    ):
        # helper to convert from question format to internal format
        self.choices = []

        if pointed_at is not None:
            self.pointed_at = pointed_at

        for i, c in enumerate(choices):
            choice = Choice.build(c)

            if self._is_selected(choice):
                self.selected_options.append(choice.value)

            if pointed_at is None and not choice.disabled:
                # find the first (available) choice
                self.pointed_at = pointed_at = i

            self.choices.append(choice)
```

--------------------------------

### questionary.confirm

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Creates a yes or no confirmation prompt. Returns a Question instance that can be executed with .ask().

```APIDOC
## questionary.confirm(message, default=True, qmark='?', style=None, auto_enter=True, instruction=None, **kwargs)

### Description
A yes or no question. The user can either confirm or deny. If the user just hits enter, the default value will be returned.

### Parameters
- **message** (str) - Required - Question text.
- **default** (bool) - Optional - Default value returned if user hits enter.
- **qmark** (str) - Optional - Question prefix displayed in front of the question.
- **style** (Optional[Style]) - Optional - Custom color and style for the question parts.
- **auto_enter** (bool) - Optional - If True, valid input is accepted without pressing Enter.
- **instruction** (Optional[str]) - Optional - Message describing how to proceed.

### Returns
- **Question** - Instance ready to be prompted using .ask().
```

--------------------------------

### Complex Workflow Configuration

Source: https://questionary.readthedocs.io/en/stable/pages/advanced.html

Advanced usage demonstrating conditional logic, custom validation, and separators within a dictionary-based workflow.

```python
from pprint import pprint

from questionary import Separator
from questionary import prompt


def ask_dictstyle(**kwargs):
    questions = [
        {
            # just print a message, don't ask a question
            # does not require a name (but if provided, is ignored) and does not return a value
            "type": "print",
            "name": "intro",
            "message": "This example demonstrates advanced features! 🦄",
            "style": "bold italic",
        },
        {
            "type": "confirm",
            "name": "conditional_step",
            "message": "Would you like the next question?",
            "default": True,
        },
        {
            "type": "text",
            "name": "next_question",
            "message": "Name this library?",
            # Validate if the first question was answered with yes or no
            "when": lambda x: x["conditional_step"],
            # Only accept questionary as answer
            "validate": lambda val: val == "questionary",
        },
        {
            "type": "select",
            "name": "second_question",
            "message": "Select item",
            "choices": ["item1", "item2", Separator(), "other"],
        },
        {
            # just print a message, don't ask a question
            # does not require a name and does not return a value
            "type": "print",
            "message": "Please enter a value for 'other'",
            "style": "bold italic fg:darkred",
            "when": lambda x: x["second_question"] == "other",
        },
        {
            "type": "text",
            # intentionally overwrites result from previous question
            "name": "second_question",
            "message": "Insert free text",
            "when": lambda x: x["second_question"] == "other",
        },
    ]
    return prompt(questions, **kwargs)


if __name__ == "__main__":
    pprint(ask_dictstyle())
```

--------------------------------

### InquirerControl Class Initialization

Source: https://questionary.readthedocs.io/en/stable/_modules/questionary/prompts/common.html

Initializes the InquirerControl class, setting up various options for interactive prompts like use_indicator, use_shortcuts, and use_arrow_keys.

```python
class InquirerControl(FormattedTextControl):
    SHORTCUT_KEYS = [
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "0",
        "a",
        "b",
        "c",
        "d",
        "e",
        "f",
        "g",
        "h",
        "i",
        "j",
        "k",
        "l",
        "m",
        "n",
        "o",
        "p",
        "q",
        "r",
        "s",
        "t",
        "u",
        "v",
        "w",
        "x",
        "y",
        "z",
    ]

    choices: List[Choice]
    default: Optional[Union[str, Choice, Dict[str, Any]]]
    selected_options: List[Any]
    use_indicator: bool
    use_shortcuts: bool
    use_arrow_keys: bool
    pointer: Optional[str]
    pointed_at: int
    is_answered: bool

    def __init__(
        self,
        choices: Sequence[Union[str, Choice, Dict[str, Any]]],
        default: Optional[Union[str, Choice, Dict[str, Any]]] = None,
        pointer: Optional[str] = DEFAULT_SELECTED_POINTER,
        use_indicator: bool = True,
        use_shortcuts: bool = False,
        show_selected: bool = False,
        use_arrow_keys: bool = True,
        initial_choice: Optional[Union[str, Choice, Dict[str, Any]]] = None,
        **kwargs: Any,
    ):
        self.use_indicator = use_indicator
        self.use_shortcuts = use_shortcuts

```

--------------------------------

### Prompt for free text input

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Basic usage of the text prompt to capture user input.

```python
>>> import questionary
>>> questionary.text("What's your first name?").ask()
? What's your first name? Tom
'Tom'
```

--------------------------------

### Convert recording to GIF

Source: https://questionary.readthedocs.io/en/stable/pages/contributors.html

Converts an asciinema recording file into a GIF animation with specified dimensions.

```bash
$ asciicast2gif -h 7 -w 120 -s 2 <recording> output.gif
```

--------------------------------

### Create a Confirmation Prompt

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Prompts the user for a yes or no answer. Returns a boolean value based on user input.

```python
>>> import questionary
>>> questionary.confirm("Are you amazed?").ask()
? Are you amazed? Yes
True
```

--------------------------------

### Prompt for a file path

Source: https://questionary.readthedocs.io/en/stable/pages/types.html

Prompts the user for a file or directory path with built-in autocompletion support.

```python
>>> import questionary
>>> questionary.path(
>>>    "What's the path to the projects version file?"
>>> ).ask()
? What's the path to the projects version file? ./pyproject.toml
'./pyproject.toml'
```

--------------------------------

### questionary.Form

Source: https://questionary.readthedocs.io/en/stable/pages/api_reference.html

Handles multi-question prompts where questions are asked sequentially and results are returned as a dictionary.

```APIDOC
## class questionary.Form(form_fields)

### Description
Manages a collection of questions to be asked in sequence. It is recommended to use the `form()` function rather than instantiating this class directly.

### Methods
- **ask(patch_stdout=False, kbi_msg='Cancelled by user')** - Synchronously asks questions and returns a dictionary of answers.
- **ask_async(patch_stdout=False, kbi_msg='Cancelled by user')** - Asynchronously asks questions and returns a dictionary of answers.
- **unsafe_ask(patch_stdout=False)** - Synchronously asks questions without catching keyboard interrupts.
- **unsafe_ask_async(patch_stdout=False)** - Asynchronously asks questions without catching keyboard interrupts.
```
Tokens:
Raw