InquirerPy renders interactive CLI prompts with arrow-key menus, checkboxes, and validated text input. pip install InquirerPy. Select: from InquirerPy import inquirer; result = inquirer.select(message="Choose env:", choices=["dev","staging","prod"]).execute(). Text: inquirer.text(message="Name:", default="app").execute(). Password: inquirer.secret(message="API key:").execute(). Number: inquirer.number(message="Port:", default=8000, min_allowed=1, max_allowed=65535).execute(). Confirm: inquirer.confirm(message="Deploy?", default=True).execute(). Checkbox: inquirer.checkbox(message="Select:", choices=["a","b","c"]).execute() → list. Fuzzy: inquirer.fuzzy(message="Search:", choices=["apple","banana","cherry"]).execute(). Filepath: inquirer.filepath(message="Config:", default=".").execute(). Rawlist: numbered list selection inquirer.rawlist(message="Choose:", choices=["a","b"]).execute(). Validation: validate=lambda x: len(x)>0 or "Required". invalid_message="Field is required". Filter: filter=str.upper. When (conditional): when=lambda answers: answers["deploy"] == True. Dict form: from InquirerPy import prompt; result = prompt([{"type":"select","name":"env","message":"Env:","choices":["dev","prod"]}, {"type":"text","name":"tag","message":"Tag:"}]). Separator: from InquirerPy.base.control import Choice; from InquirerPy.separator import Separator. Keybindings: keybindings={"toggle-all-true": [{"key":"ctrl-a"}]}. Style: InquirerPy.utils.color_print(...). Instruction text: instruction="(arrow keys)". Claude Code generates InquirerPy prompt wizards, deploy flows, and multi-step CLI configuration forms.
CLAUDE.md for InquirerPy
## InquirerPy Stack
- Version: InquirerPy >= 0.3 | pip install InquirerPy
- Select: inquirer.select(message="...", choices=[...]).execute() → str
- Multi: inquirer.checkbox(message="...", choices=[...]).execute() → list[str]
- Fuzzy: inquirer.fuzzy(message="...", choices=[...]).execute() → str
- Validate: validate=lambda x: len(x)>0 or "Required" — return True or str error
- Conditional: when=lambda answers: answers["key"] == value
- Form: prompt([{"type":"select","name":"k","message":"...","choices":[...]},...])InquirerPy Interactive Prompt Pipeline
# app/prompts.py — InquirerPy prompts, validation, and multi-step wizards
from __future__ import annotations
import os
import sys
from pathlib import Path
from typing import Any, Callable
from InquirerPy import inquirer, prompt
from InquirerPy.base.control import Choice
from InquirerPy.separator import Separator
# ─────────────────────────────────────────────────────────────────────────────
# 1. Single-prompt wrappers
# ─────────────────────────────────────────────────────────────────────────────
def ask_select(
message: str,
choices: list[str | Choice],
default: str | None = None,
instruction: str = "",
) -> str:
"""Arrow-key single-select menu. Returns chosen string."""
return inquirer.select(
message=message,
choices=choices,
default=default,
instruction=instruction or "(↑↓ arrow keys, Enter to confirm)",
).execute()
def ask_checkbox(
message: str,
choices: list[str | Choice],
default: list[str] | None = None,
instruction: str = "",
validate: Callable | None = None,
) -> list[str]:
"""Multi-select checkbox. Returns list of selected strings."""
kw: dict[str, Any] = {
"message": message,
"choices": choices,
"instruction": instruction or "(Space to toggle, Enter to confirm)",
}
if default is not None:
kw["default"] = default
if validate:
kw["validate"] = validate
return inquirer.checkbox(**kw).execute()
def ask_text(
message: str,
default: str = "",
validate: Callable | None = None,
filter_fn: Callable | None = None,
instruction: str = "",
) -> str:
"""Free-text input with optional validation and transform."""
kw: dict[str, Any] = {"message": message, "default": default}
if validate:
kw["validate"] = validate
if filter_fn:
kw["filter"] = filter_fn
if instruction:
kw["instruction"] = instruction
return inquirer.text(**kw).execute()
def ask_secret(message: str, validate: Callable | None = None) -> str:
"""Password / secret input (characters masked)."""
kw: dict[str, Any] = {"message": message}
if validate:
kw["validate"] = validate
return inquirer.secret(**kw).execute()
def ask_number(
message: str,
default: int = 0,
min_val: int | None = None,
max_val: int | None = None,
) -> int:
"""Numeric input with optional min/max bounds."""
kw: dict[str, Any] = {"message": message, "default": default}
if min_val is not None:
kw["min_allowed"] = min_val
if max_val is not None:
kw["max_allowed"] = max_val
return inquirer.number(**kw).execute()
def ask_confirm(message: str, default: bool = True) -> bool:
"""Yes / No confirmation. Returns bool."""
return inquirer.confirm(message=message, default=default).execute()
def ask_fuzzy(
message: str,
choices: list[str],
default: str | None = None,
instruction: str = "",
) -> str:
"""Fuzzy-searchable list picker. Type to filter, Enter to select."""
return inquirer.fuzzy(
message=message,
choices=choices,
default=default or (choices[0] if choices else ""),
instruction=instruction or "(type to search, Enter to select)",
).execute()
def ask_filepath(
message: str,
default: str = ".",
only_files: bool = True,
) -> str:
"""Path picker with Tab-completion."""
return inquirer.filepath(
message=message,
default=default,
only_files=only_files,
).execute()
# ─────────────────────────────────────────────────────────────────────────────
# 2. Validators
# ─────────────────────────────────────────────────────────────────────────────
def required(v: str) -> bool | str:
return True if v.strip() else "This field is required"
def min_length(n: int) -> Callable:
def _v(v: str) -> bool | str:
return True if len(v) >= n else f"Must be at least {n} characters"
return _v
def must_be_port(v: int | str) -> bool | str:
try:
port = int(v)
return True if 1 <= port <= 65535 else "Port must be 1–65535"
except (ValueError, TypeError):
return "Must be a number"
def path_exists(v: str) -> bool | str:
return True if Path(v).exists() else f"Path not found: {v}"
def nonempty_list(v: list) -> bool | str:
return True if v else "Select at least one option"
# ─────────────────────────────────────────────────────────────────────────────
# 3. Multi-step wizard via prompt()
# ─────────────────────────────────────────────────────────────────────────────
def deploy_wizard() -> dict[str, Any]:
"""
Interactive deploy wizard collecting environment, tag, confirmation.
Uses prompt() dict-driven form for full conditional support.
"""
questions = [
{
"type": "select",
"name": "environment",
"message": "Target environment:",
"choices": ["development", "staging", "production"],
},
{
"type": "text",
"name": "image_tag",
"message": "Docker image tag:",
"default": "latest",
"validate": lambda v: len(v.strip()) > 0 or "Tag is required",
},
{
"type": "checkbox",
"name": "services",
"message": "Services to deploy:",
"choices": [
Choice("api", enabled=True),
Choice("worker", enabled=True),
Choice("scheduler", enabled=False),
Separator("── Infra ──"),
Choice("redis", enabled=False),
Choice("postgres", enabled=False),
],
"validate": nonempty_list,
},
{
"type": "confirm",
"name": "run_migrations",
"message": "Run database migrations?",
"default": True,
"when": lambda a: "postgres" in a.get("services", []),
},
{
"type": "confirm",
"name": "confirm",
"message": lambda a: f"Deploy {a['image_tag']} to {a['environment']}?",
"default": False,
"when": lambda a: a.get("environment") == "production",
},
]
return prompt(questions)
def database_wizard() -> dict[str, Any]:
"""Collect database connection parameters interactively."""
return prompt([
{
"type": "select",
"name": "engine",
"message": "Database engine:",
"choices": ["PostgreSQL", "MySQL", "SQLite"],
},
{
"type": "text",
"name": "host",
"message": "Host:",
"default": "localhost",
"when": lambda a: a["engine"] != "SQLite",
"validate": required,
},
{
"type": "number",
"name": "port",
"message": "Port:",
"default": 5432,
"when": lambda a: a["engine"] == "PostgreSQL",
"min_allowed": 1,
"max_allowed": 65535,
},
{
"type": "number",
"name": "port",
"message": "Port:",
"default": 3306,
"when": lambda a: a["engine"] == "MySQL",
},
{
"type": "text",
"name": "database",
"message": "Database name:",
"validate": required,
},
{
"type": "text",
"name": "user",
"message": "Username:",
"when": lambda a: a["engine"] != "SQLite",
},
{
"type": "secret",
"name": "password",
"message": "Password:",
"when": lambda a: a["engine"] != "SQLite",
},
])
# ─────────────────────────────────────────────────────────────────────────────
# 4. Reusable form builder
# ─────────────────────────────────────────────────────────────────────────────
class PromptForm:
"""
Build multi-step prompt forms programmatically.
Usage:
form = PromptForm()
form.select("env", "Environment:", ["dev","staging","prod"])
form.text("tag", "Tag:", default="latest", validate=required)
form.confirm("ok", "Continue?")
answers = form.run()
"""
def __init__(self):
self._questions: list[dict[str, Any]] = []
def select(
self,
name: str,
message: str,
choices: list[str | Choice],
when: Callable | None = None,
) -> "PromptForm":
q: dict[str, Any] = {"type": "select", "name": name, "message": message, "choices": choices}
if when:
q["when"] = when
self._questions.append(q)
return self
def checkbox(
self,
name: str,
message: str,
choices: list[str | Choice],
validate: Callable | None = None,
when: Callable | None = None,
) -> "PromptForm":
q: dict[str, Any] = {"type": "checkbox", "name": name, "message": message, "choices": choices}
if validate:
q["validate"] = validate
if when:
q["when"] = when
self._questions.append(q)
return self
def text(
self,
name: str,
message: str,
default: str = "",
validate: Callable | None = None,
when: Callable | None = None,
) -> "PromptForm":
q: dict[str, Any] = {"type": "text", "name": name, "message": message, "default": default}
if validate:
q["validate"] = validate
if when:
q["when"] = when
self._questions.append(q)
return self
def confirm(
self,
name: str,
message: str | Callable,
default: bool = True,
when: Callable | None = None,
) -> "PromptForm":
q: dict[str, Any] = {"type": "confirm", "name": name, "message": message, "default": default}
if when:
q["when"] = when
self._questions.append(q)
return self
def fuzzy(
self,
name: str,
message: str,
choices: list[str],
when: Callable | None = None,
) -> "PromptForm":
q: dict[str, Any] = {"type": "fuzzy", "name": name, "message": message, "choices": choices}
if when:
q["when"] = when
self._questions.append(q)
return self
def run(self) -> dict[str, Any]:
return prompt(self._questions)
# ─────────────────────────────────────────────────────────────────────────────
# Demo
# ─────────────────────────────────────────────────────────────────────────────
if __name__ == "__main__":
if not sys.stdout.isatty():
print("Demo requires a TTY — run in a real terminal.")
sys.exit(0)
print("=== Single selects ===")
env = ask_select("Environment:", ["development", "staging", "production"])
print(f" env: {env!r}")
color = ask_fuzzy("Favorite color:", ["red", "green", "blue", "yellow", "purple"])
print(f" color: {color!r}")
print("\n=== Text + secret ===")
name = ask_text("App name:", default="myapp", validate=min_length(2))
print(f" name: {name!r}")
print("\n=== Checkbox ===")
features = ask_checkbox(
"Enable features:",
choices=[
Choice("cache", enabled=True),
Choice("metrics", enabled=True),
Choice("tracing", enabled=False),
Choice("profiling",enabled=False),
],
validate=nonempty_list,
)
print(f" features: {features}")
print("\n=== Number + confirm ===")
port = ask_number("Port:", default=8000, min_val=1, max_val=65535)
ok = ask_confirm(f"Start server on port {port}?")
print(f" port={port}, confirmed={ok}")
print("\n=== PromptForm builder ===")
answers = (
PromptForm()
.select("action", "Action:", ["deploy", "rollback", "status"])
.text("version", "Version tag:", default="v1.0.0", validate=required)
.confirm(
"dry_run",
"Dry run only?",
default=True,
when=lambda a: a.get("action") == "deploy",
)
.run()
)
print(f" answers: {answers}")For the questionary alternative — questionary is the most popular InquirerPy-style library and uses prompt_toolkit under the hood too, but InquirerPy is a more active fork with additional prompt types (fuzzy, filepath, number), a better when/validate/filter API, and cleaner async support; both are good choices with nearly identical APIs, with InquirerPy having a slight edge for projects that need fuzzy search or file completion. For the PyInquirer alternative — PyInquirer is the original Python library powering this API but is no longer actively maintained and has Python 3.10+ compatibility issues; InquirerPy is the maintained replacement with the same prompt() dict-driven interface plus many additions. The Claude Skills 360 bundle includes InquirerPy skill sets covering inquirer.select/checkbox/text/secret/number/confirm/fuzzy/filepath, prompt() dict-form with when/validate/filter, required/min_length/must_be_port/nonempty_list validators, deploy_wizard() and database_wizard() multi-step forms, PromptForm builder API, Choice() with enabled default, Separator() visual dividers, conditional questions with when lambda, and KeyboardInterrupt handling. Start with the free tier to try interactive CLI prompt code generation.