def get_filepath_validator(self):
"""Return a validator for a existing file path."""
Validator.from_callable(
self._is_valid_file_path,
error_message="Please enter a valid file path.",
move_cursor_to_end=True,
)
async def _prompt_time(self) -> datetime.datetime:
"""
Prompt the client for a time within the week.
"""
def parse_time(s: str) -> datetime.datetime:
t = START_DATE.strptime(s, "%H:%M")
return START_DATE.replace(hour=t.hour, minute=t.minute)
def validate_time(s: str) -> bool:
try:
parse_time(s)
return True
except ValueError:
return False
validator = Validator.from_callable(
validate_time, "expecting a time in HH:MM format")
dt = parse_time(await self._session.prompt_async(
HTML("<i><b>Time</b> of day (HH:MM)</i>? >>> "),
validator=validator,
))
dow = await self._prompt_dow(exclude=tuple())
dt += datetime.timedelta(days=next(iter(dow)).value)
return dt
def set_due_date(card):
'''prompt for the date to set this card due as'''
def validate_date(text):
return re.match(r'\d{2}\/\d{2}\/\d{4}', text) or re.match(
r'[A-Z][a-z]{2} \d{2} \d{4}', text)
validator = Validator.from_callable(
validate_date,
error_message=
'Enter a date in format "Jun 15 2018", "06/15/2018" or "15/06/2018". Ctrl+C to go back',
move_cursor_to_end=True,
)
while True:
try:
user_input = prompt('date > ',
validator=validator,
validate_while_typing=True)
except KeyboardInterrupt:
return
result = parse_user_date_input(user_input)
if result is None:
print('Invalid date format!')
else:
break
card.set_due(result)
card.fetch() # Needed to pick up the new due date
print('Due date set')
return result
def ask_for_progress() -> str:
validator = Validator.from_callable(
is_valid_progress,
error_message=
'Must be a whole number (no % sign), F for "Finished", or A for "Abandoned"',
move_cursor_to_end=True,
)
progress = ask.prompt(
"Progress: ",
validator=validator,
default="",
rprompt=
'Whole number (no % sign), F for "Finished", or A for "Abandoned"',
)
if progress:
if progress == "F":
return "Finished"
if progress == "A":
return "Abandoned"
return "{0}%".format(progress)
return ask_for_progress()
def _reset(self):
self._answered: bool = False
self._buffer: Buffer = Buffer(
validator=Validator.from_callable(self._validate),
name=DEFAULT_BUFFER,
accept_handler=self._submit,
)
def __prompt_for_account(account_names):
print("{}#--------------------------------------------------#".format(
Colors.lblue))
print("# {}To which account would you like to login?{} #".format(
Colors.white, Colors.lblue))
print("# {}Start typing an account name or{} #".format(
Colors.white, Colors.lblue))
print('# {}"list" to list accounts{} #'.format(
Colors.white, Colors.lblue))
print("#--------------------------------------------------#{}".format(
Colors.normal))
account_names.append("list")
def is_valid(account):
return account in account_names
account_completer = FuzzyWordCompleter(account_names, WORD=True)
validator = Validator.from_callable(is_valid,
error_message="Not a valid account",
move_cursor_to_end=True)
while True:
account = prompt(
"Account: ",
completer=account_completer,
complete_while_typing=True,
validator=validator,
)
if account == "list":
for account_name in account_names:
if account_name != "list":
print("\t{}{}{}".format(Colors.yellow, account_name,
Colors.normal))
else:
return account
def chose_install_dir(json_file):
validator = Validator.from_callable(
lambda x: os.path.isdir(x) or x == '',
error_message="Not a directory!",
move_cursor_to_end=True,
)
path_completer = PathCompleter(only_directories=True)
default_dir = json_file['install_dir'] or './'
question = "\nPath to install datasets [empty to default " + \
default_dir + "] "
install_dir = prompt(question,
validator=validator,
completer=path_completer)
if not install_dir:
if not os.path.isdir(default_dir):
os.mkdir(default_dir)
install_dir = default_dir
if install_dir.endswith('/'):
install_dir = install_dir[:-1]
json_file['install_dir'] = install_dir
return install_dir
def get_confirm_validator(self):
"""Return a validator for confirmation y or n."""
return Validator.from_callable(
self._is_valid_confirm,
error_message="Please enter 'y' or 'n' to continue.",
move_cursor_to_end=True,
)
def _make_integer_validator(self, allow_empty=False):
"""
Create a validator for integer fields.
This private method creates a validator for a field
with ``data_type`` of "integers".
Parameters
----------
allow_empty : bool, optional
If ``True``, it will allow the user to also just press
enter (i.e., input a blank string)
Defaults to ``False``.
Returns
-------
validator : prompt_toolkit.validation.Validator
A ``Validator`` instance that makes sure that the
final user input is a string representation of a
fixed-point number or integer. Blank strings may
also be allowed if ``allow_empty`` is ``True``.
"""
integer_regex = r'^[0-9]+$'
if allow_empty:
integer_regex += r'|^$'
validator = Validator.from_callable(
lambda answer: re.match(integer_regex, answer),
error_message="invalid integer")
return validator
def get_path_validator(self):
"""Return a validator for a valid path."""
return Validator.from_callable(
self._is_valid_path,
error_message="Please enter a valid path.",
move_cursor_to_end=True,
)
def play(rows_to_win: int, starting_rows: int, columns: int) -> None:
"""Play the game.
Args:
columns: The number of columns in the grid. Increasing this makes the game more difficult.
starting_rows: The number of rows in the grid when the game starts. Increasing this makes the game more
difficult.
rows_to_win: The total number of rows that must be in the grid to win the game. Increasing this makes the game
more difficult.
"""
char_grid = create_grid(starting_rows, columns)
usernames = random.sample(USERNAMES, rows_to_win)
pad_width = len(max(usernames, key=len))
# Format and print the initial grid.
starting_grid = "\n".join(
format_line(usernames.pop(), pad_width, line)
for line in char_grid.format().splitlines())
print(starting_grid)
# Create the prompt session.
validator = Validator.from_callable(char_grid.check_row,
error_message="Invalid row",
move_cursor_to_end=True)
session = PromptSession(validator=validator,
validate_while_typing=False,
mouse_support=True,
style=GUI_STYLE)
# Prompt the user until they complete enough lines.
while len(char_grid.rows) < rows_to_win:
session.prompt(format_line(usernames.pop(), pad_width, ""))
print_correct_message()
def set_due_date(self):
def validate_date(text):
return re.match(r'\d{2}\/\d{2}\/\d{4}', text) or re.match(
r'[A-Z][a-z]{2} \d{2} \d{4}', text)
validator = Validator.from_callable(
validate_date,
error_message=
'Enter a date in format "Jun 15 2018", "06/15/2018" or "15/06/2018". Ctrl+D to go back',
move_cursor_to_end=True,
)
while True:
user_input = prompt('gtd.py > duedate > ',
validator=validator,
validate_while_typing=True)
result = parse_user_date_input(user_input)
if result is None:
print('Invalid date format!')
else:
break
# Set the due daet
self.connection.trello.fetch_json(
'/cards/' + self.id + '/due',
http_method='PUT',
post_args={'value': result.isoformat()})
# Pick it up
self.fetch()
print('Due date set')
return result
def _make_boolean_validator(self, allow_empty=False):
"""
Create a validator for boolean fields.
This private method creates a validator for a field with
``data_type`` of "boolean".
Parameters
----------
allow_empty : bool, optional
If ``True``, it will allow the user to also just press
enter (i.e., input a blank string), in addition to "true"
or "false".
Defaults to ``False``.
Returns
-------
validator : prompt_toolkit.validation.Validator
A ``Validator`` instance that ensures that the user
input for the field is "true" / "false", or possibly
the empty string, if ``allow_empty`` is ``True``.
"""
correct_choices = ["true", "false"]
if allow_empty:
correct_choices.append("")
validator = Validator.from_callable(
lambda answer: answer in correct_choices,
error_message="invalid answer")
return validator
def set_validator(s):
options_str = ', '.join(sorted(list(s)))
return Validator.from_callable(
lambda i: i in s,
error_message=
"Sorry, that's not a valid option. Try one of these: " +
options_str + ". Tab complete may help!",
move_cursor_to_end=True)
def number_validator(lbound=None, ubound=None):
return Validator.from_callable(
lambda s: s == "" or
(is_number(s) and in_bounds(s, lbound, ubound)),
error_message='This input may only contain numeric characters' +
('' if lbound is None else ' and it must be >= %d' % lbound) +
('' if ubound is None else ' and it must be < %d' % ubound),
move_cursor_to_end=True)
def get_list_prompt(lists, error_message='the input is not in list'):
completer = WordCompleter(lists)
validator = Validator.from_callable(
lambda x: x in lists,
error_message='This verb is not in this book. ',
move_cursor_to_end=True)
return completer, validator
def existing_config(self):
path_exist_validator = Validator.from_callable(os.path.exists,
error_message='Path does not exist, choose existing path',
move_cursor_to_end=True)
config_directory = prompt('%s: ' % 'Existing config directory name',
completer=PathCompleter(only_directories=True, expanduser=True),
validator=path_exist_validator)
return self.read_existing_config(config_directory)
def get_type_validator(self):
"""Return a validator for a valid type."""
return Validator.from_callable(
self._is_valid_class_name,
error_message="Please only enter a number [0-%s]. " %
(len(self._valid_types) - 1),
move_cursor_to_end=True,
)
def get_class_name_validator(self):
"""Return a validator for a valid identifier."""
return Validator.from_callable(
self._is_valid_class_name,
error_message=
"Please enter a valid name (only contain digits and letters).",
move_cursor_to_end=True,
)
def test_validator_instance():
def validate(t):
return len(t) == 3
validator = Validator.from_callable(validate)
validator = build_validator(validator)
assert validator.validate(Document("foo")) is None # should not raise
def test_validator_instance_fails():
def validate(t):
return len(t) == 3
validator = Validator.from_callable(validate, error_message="invalid input")
with pytest.raises(ValidationError) as e:
validator.validate(Document("fooooo"))
assert e.value.message == "invalid input"
async def _prompt_facility(self) -> str:
"""
Prompt the client for a facility name.
"""
return await self._session.prompt_async(
HTML("<i>Facility <b>name</b></i>? >>> "),
validator=Validator.from_callable(lambda v: True),
completer=WordCompleter(list(self._known_facilities)),
)
def ask(self):
self.answer = questionary.text(
"Please provide the name for instance profile",
validate=Validator.from_callable(
lambda x: 0 < len(x) < 64,
error_message=
"Instance profile name shouldn't be empty or longer than 64 chars"
),
style=custom_style).ask()
return self.answer
def file_validation():
files = []
for f in os.listdir('./'):
file_name, file_extension = os.path.splitext(f)
if file_extension in {'.csv', '.CSV'}:
files.append(f)
is_valid = lambda text: text in files
return Validator.from_callable(
is_valid,
error_message=
'Please enter the name of a CSV file in the working directory.')
def validator(self):
"""
"""
def service_is_valid(service):
return service.title() in self.available_services
error_message = f"Service must be one of: {self.available_services}"
validator = Validator.from_callable(service_is_valid,
error_message=error_message,
move_cursor_to_end=True)
return validator
def input(
title,
default="",
bottom_toolbar=None,
multiline=False,
validator_function=None,
default_message=""
):
"""Prompt user for input
:param title: Title of the pager
:type title: str
:param default: Default value to give if the user does not input anything
:type default: str
:param validator_function: User's input has to fulfill validator functions
:type validator_function: function
:param default_message: Default message to prompt
:type default_message: str
:return: User input or default
:rtype : bool
"""
import prompt_toolkit
from prompt_toolkit.validation import Validator
validator = None
if validator_function is not None:
validator = Validator.from_callable(
validator_function,
error_message=default_message,
move_cursor_to_end=True
)
fragments = title
if isinstance(title, str):
fragments = [
('', title),
('fg:red', ' ({0})'.format(default)),
('', ': '),
]
result = prompt_toolkit.prompt(
fragments,
validator=validator,
multiline=multiline,
bottom_toolbar=bottom_toolbar,
validate_while_typing=True
)
return result if result else default
def prompt_options(message, options, strict=False, history=None):
completer = FuzzyWordCompleter(options, WORD=True)
if strict:
validator = Validator.from_callable(lambda s: s in options,
error_message='',
move_cursor_to_end=False)
return p(message + ' ',
completer=completer,
vi_mode=True,
validator=validator,
history=history)
return prompt(message, completer=completer, history=history)
def main():
args = get_args()
session = PromptSession(
history=FileHistory('/tmp/sctp-injector-inter.history'))
SCRIPT_PATH = os.path.abspath(os.path.dirname(__file__))
script_file = session.prompt(
'Choose a Python sub-script to run inside > ',
completer=PathCompleter(),
validator=Validator.from_callable(
lambda p: os.path.exists(p) and p.endswith(".py")),
complete_while_typing=True)
print('You said: %s' % script_file)
def __get_commond_attr(self):
msg = self.answer['msg']
default = '' if not "default" in self.answer else self.answer["default"]
validator_dict = None if not "validator" in self.answer else self.answer[
"validator"]
validator = None
if validator_dict:
validator = Validator.from_callable(
validator_dict['callback'],
error_message=validator_dict['error_msg'],
move_cursor_to_end=True)
return msg, default, validator
def qa_input(movie: Dict[str, Any]) -> str:
print('Title: {[title]} dir. '.format(movie), end='')
for name in movie['directors'][:-1]:
print(f'{name}, ')
print(movie['directors'][-1]['name'])
return session.prompt(
'Release Year> ',
validator=Validator.from_callable(
lambda x: x.isdigit(),
error_message='Not a valid year',
move_cursor_to_end=True
))
#!/usr/bin/env python
"""
Simple example of input validation.
"""
from prompt_toolkit import prompt
from prompt_toolkit.validation import Validator
def is_valid_email(text):
return '@' in text
validator = Validator.from_callable(
is_valid_email,
error_message='Not a valid e-mail address (Does not contain an @).',
move_cursor_to_end=True)
def main():
# Validate when pressing ENTER.
text = prompt('Enter e-mail address: ', validator=validator,
validate_while_typing=False)
print('You said: %s' % text)
# While typing
text = prompt('Enter e-mail address: ', validator=validator,
validate_while_typing=True)
print('You said: %s' % text)
if __name__ == '__main__':