def new(*args, **kwargs):
project_name = kwargs["project_name"]
description = click.prompt("description")
author_name = click.prompt("author_name")
author_email = click.prompt("author_email")
license_completer = FuzzyWordCompleter(licenses)
license = prompt(
"Select license: ",
completer=license_completer,
complete_while_typing=True,
)
classifier_completer = FuzzyWordCompleter(classifiers)
classifier = prompt(
"Select classifier: ",
completer=classifier_completer,
complete_while_typing=True,
)
metadata = {
"name": project_name,
"description": description,
"author_name": author_name,
"author_email": author_email,
"license": license,
"classifiers": classifier,
}
print()
pprint(metadata)
def completion(self, document, complete_event=None):
# complete_event is None when this method is called by complete_input()
if complete_event == None and len(document.text) == 0:
return
t = document.text.split()
if len(t) == 0 or (len(t) == 1 and document.text[-1] != ' '):
# command completion
if self.fuzzy_completion and complete_event:
c = FuzzyWordCompleter(self.commands())
for v in c.get_completions(document, complete_event):
yield v
else:
for cmd in self.commands():
if cmd.startswith(document.text):
yield Completion(cmd,
start_position=-len(document.text))
else:
# argument completion
# complete command(t[0]) first
try:
cmd = self.complete_input([t[0]])[0]
except InvalidInput:
return
v = self._commands.get(cmd)
if not v:
return
c = v['completer']
if c:
# do argument completion with text after the command (t[0])
new_document = Document(document.text[len(t[0]):].lstrip())
for v in c.get_completions(new_document, complete_event):
yield v
def __init__(self,
words: Union[List[str], Callable[[], List[str]]],
meta_dict: Optional[Dict[str, str]] = None,
WORD: bool = False) -> None:
self.words = words
self.meta_dict = meta_dict or {}
self.WORD = WORD
self.fuzzy_word_completer = FuzzyWordCompleter(words=self.words,
WORD=self.WORD)
def test_fuzzy_completer():
collection = [
"migrations.py",
"django_migrations.py",
"django_admin_log.py",
"api_user.doc",
"user_group.doc",
"users.txt",
"accounts.txt",
"123.py",
"test123test.py",
]
completer = FuzzyWordCompleter(collection)
completions = completer.get_completions(Document("txt"), CompleteEvent())
assert [c.text for c in completions] == ["users.txt", "accounts.txt"]
completions = completer.get_completions(Document("djmi"), CompleteEvent())
assert [c.text for c in completions] == [
"django_migrations.py",
"django_admin_log.py",
]
completions = completer.get_completions(Document("mi"), CompleteEvent())
assert [c.text for c in completions] == [
"migrations.py",
"django_migrations.py",
"django_admin_log.py",
]
completions = completer.get_completions(Document("user"), CompleteEvent())
assert [c.text for c in completions] == [
"user_group.doc",
"users.txt",
"api_user.doc",
]
completions = completer.get_completions(Document("123"), CompleteEvent())
assert [c.text for c in completions] == ["123.py", "test123test.py"]
completions = completer.get_completions(Document("miGr"), CompleteEvent())
assert [c.text for c in completions] == [
"migrations.py",
"django_migrations.py",
]
# Multiple words ending with space. (Accept all options)
completions = completer.get_completions(Document("test "), CompleteEvent())
assert [c.text for c in completions] == collection
# Multiple words. (Check last only.)
completions = completer.get_completions(Document("test txt"),
CompleteEvent())
assert [c.text for c in completions] == ["users.txt", "accounts.txt"]
def test_fuzzy_completer():
collection = [
'migrations.py', 'django_migrations.py', 'django_admin_log.py',
'api_user.doc', 'user_group.doc', 'users.txt', 'accounts.txt',
'123.py', 'test123test.py'
]
completer = FuzzyWordCompleter(collection)
completions = completer.get_completions(Document('txt'), CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
completions = completer.get_completions(Document('djmi'), CompleteEvent())
assert [c.text for c in completions
] == ['django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('mi'), CompleteEvent())
assert [c.text for c in completions] == [
'migrations.py', 'django_migrations.py', 'django_admin_log.py'
]
completions = completer.get_completions(Document('user'), CompleteEvent())
assert [c.text for c in completions
] == ['user_group.doc', 'users.txt', 'api_user.doc']
completions = completer.get_completions(Document('123'), CompleteEvent())
assert [c.text for c in completions] == ['123.py', 'test123test.py']
completions = completer.get_completions(Document('miGr'), CompleteEvent())
assert [c.text for c in completions] == [
'migrations.py',
'django_migrations.py',
]
def edit_values(result) -> Tuple[str, str, str]:
title = ""
while title == "":
if result["main_title"] == result["ext_title"]:
default = result["main_title"]
else:
default = ""
title = questionary.text(
"Title:",
default=default,
completer=FuzzyWordCompleter([result["main_title"], result["ext_title"]]),
).ask()
if title is None:
raise AbortCommand
title = title.strip()
artist = ""
while artist == "":
if result["main_artist"] == result["ext_artist"]:
default = result["main_artist"]
else:
default = ""
artist = questionary.text(
"Artist:",
default=default,
completer=FuzzyWordCompleter([result["main_artist"], result["ext_artist"]]),
).ask()
if artist is None:
raise AbortCommand
artist = artist.strip()
while True:
if result["main_album"] == result["ext_album"]:
default = result["main_album"]
else:
default = ""
album = questionary.text(
"Album:",
default=default,
completer=FuzzyWordCompleter([result["main_album"], result["ext_album"]]),
).ask()
if album is None:
raise AbortCommand
album = album.strip()
if album != "":
break
if questionary.confirm("Are you sure?", auto_enter=False).ask():
break
return title, artist, album
def move_between_boards(self, card: Card) -> None:
boards_by_name = self.connection.boards_by_name()
board_name = prompt('gtd.py > move > board name? ',
completer=FuzzyWordCompleter(
boards_by_name.keys()))
board_id = boards_by_name[board_name]['id']
lists_json = self.connection.trello.fetch_json(
f'/boards/{board_id}/lists?cards=none&filter=open&fields=name')
name_to_listid = {l['name']: l['id'] for l in lists_json}
list_name = prompt(
f'gtd.py > move > {board_name} > list name? ',
completer=FuzzyWordCompleter(name_to_listid.keys()),
)
card.change_board(board_id, list_id=name_to_listid[list_name])
click.secho(f'Changed list to {list_name} on {board_name}', fg='green')
def manual_input(expense):
mapping = LabelMapping.create_from_local_copy()
tags_completer = FuzzyWordCompleter(mapping.tags)
category_completer = FuzzyWordCompleter(mapping.categories)
if category := prompt("Enter category: ",
completer=category_completer,
search_ignore_case=True):
if tag := prompt("Enter tag: ",
completer=tags_completer,
search_ignore_case=True):
logger.info('Updating manual choice')
update_entry_async(expense['id'],
category=category,
tag=tag,
desc=expense['desc'] + ' 🏷')
def course_selection_prompt():
# COURSE LIST URLs
# https://www.khanacademy.org/math/
# https://www.khanacademy.org/science/
# https://www.khanacademy.org/computing
# https://www.khanacademy.org/humanities
# https://www.khanacademy.org/economics-finance-domain
# Choose a Course Domain
course_domain_completer = FuzzyWordCompleter([
"Math", "Science", "Computing", "Humanities",
"Economics-Finance-Domain"
])
selected_course_domain = prompt("Course Domain: ",
completer=course_domain_completer)
print("Selected Course Domain: %s" % selected_course_domain)
# Get a list of all the courses in the domain
course_list = []
course_url_list = []
course_list_page_url = ("https://www.khanacademy.org/" +
selected_course_domain.lower())
print("\nDownloading Course List...\n")
# Download Selected Course Domain Page HTML
course_list_page_source = requests.get(course_list_page_url).text
course_list_page_html = BeautifulSoup(course_list_page_source, "lxml")
for courses_header_section in course_list_page_html.find_all(
"h2", class_="_158q6at"):
course_header_tag = courses_header_section.find("a", class_="_dwmetq")
course_header = courses_header_section.find("a", class_="_dwmetq").text
course_header_slug = course_header_tag["href"]
course_url_list.append("https://www.khanacademy.org" +
course_header_slug)
course_list.append(course_header)
# Choose a Course
course_list_completer = FuzzyWordCompleter(course_list)
selected_course = prompt("Course: ", completer=course_list_completer)
print("\nSelected Course Domain: %s\n" % selected_course)
# Find the selected course index and match the Course URL
selected_course_index = course_list.index(selected_course)
selected_course_url = course_url_list[selected_course_index]
return selected_course_url
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 allocate_datafile_prompt(context):
# Todo consider getting datafile at runtime to allow
# For one configuration to apply to multiple data files
datafile = data_filepath_prompt(context)
output_dir = output_dir_prompt(context)
# TODO test documents for mappings
column = False
header = context['datafile'].header
while not column:
print("Column choices are: " + ', '.join(header) + "\n")
column_completer = FuzzyWordCompleter(header)
column = prompt("Enter a Column to filter on: ",
completer=column_completer)
if column in header:
break
column = False
print("Invalid entry, try again (must choose an item from the list).")
writer = csv.writer
nobody = allocate(datafile, context['documents'], column)
nobody.save_buffer(output_dir, writer)
# TODO iterate on documents, not documents.values
[
doc.save_buffer(output_dir, writer, header)
for doc in context['documents'].values()
]
print("Done. Files saved to {}".format(output_dir))
def add_labels(self, label_choices):
'''Give the user a way to toggle labels on this card by their
name rather than by a numeric selection interface. Using
prompt_toolkit, we have automatic completion which makes
things substantially faster without having to do a visual
lookup against numeric IDs
Options:
label_choices: str->trello.Label, the names and objects of labels on this board
'''
print('Enter a tag name to toggle it, <TAB> completes. Ctrl+D to exit')
while True:
label_completer = FuzzyWordCompleter(label_choices.keys())
userinput = prompt('gtd.py > tag > ',
completer=label_completer).strip()
if userinput not in label_choices.keys():
if prompt_for_confirmation(
f'Unrecognized tag name {userinput}, would you like to create it?',
False):
label = self.connection.main_board().add_label(
userinput, 'green')
self.add_label(label.id)
click.echo(
f'Added tag {label.name} to board {self.connection.main_board().name} and to the card {self}'
)
label_choices[userinput] = label
else:
label_obj = label_choices[userinput]
try:
self.add_label(label_obj.id)
click.secho(f'Added tag {userinput}', fg='green')
except trello.exceptions.ResourceUnavailable:
# This label already exists on the card so remove it
self.remove_label(label_obj.id)
click.secho(f'Removed tag {userinput}', fg='red')
def __init__(self, commands):
Thread.__init__(self)
self.setName("BazookaPrompt")
self.commands = commands
completer = FuzzyWordCompleter(self.commands.keys())
self.session = PromptSession(completer=completer)
def test_fuzzy_completer():
collection = [
'migrations.py',
'django_migrations.py',
'django_admin_log.py',
'api_user.doc',
'user_group.doc',
'users.txt',
'accounts.txt',
'123.py',
'test123test.py'
]
completer = FuzzyWordCompleter(collection)
completions = completer.get_completions(Document('txt'), CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
completions = completer.get_completions(Document('djmi'), CompleteEvent())
assert [c.text for c in completions] == ['django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('mi'), CompleteEvent())
assert [c.text for c in completions] == ['migrations.py', 'django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('user'), CompleteEvent())
assert [c.text for c in completions] == ['user_group.doc', 'users.txt', 'api_user.doc']
completions = completer.get_completions(Document('123'), CompleteEvent())
assert [c.text for c in completions] == ['123.py', 'test123test.py']
completions = completer.get_completions(Document('miGr'), CompleteEvent())
assert [c.text for c in completions] == ['migrations.py', 'django_migrations.py',]
def default_input(prompt, default, options=[], ignore_case=False, retry=False):
if options:
completer = FuzzyWordCompleter(options)
return prompt_toolkit.prompt(prompt,
default=default,
completer=completer,
complete_while_typing=True,
validator=YNValidator(options))
return prompt_toolkit.prompt(prompt, default=default)
def add_labels(card, label_choices=None):
'''Give the user a way to toggle labels on this card by their
name rather than by a numeric selection interface. Using
prompt_toolkit, we have automatic completion which makes
things substantially faster without having to do a visual
lookup against numeric IDs
:param trello.Card card: the card to modify
:param dict label_choices: str->trello.Label, the names and objects of labels on this board
'''
print(
'Enter a tag name to toggle it, <TAB> completes. Give "ls" to list tags, Enter to exit'
)
label_choices = label_choices or BoardTool.label_lookup(card.board)
label_completer = FuzzyWordCompleter(label_choices.keys())
while True:
userinput = prompt('tag > ', completer=label_completer).strip()
if userinput == '':
break
elif userinput == 'ls':
triple_column_print(label_choices.keys())
elif userinput not in label_choices.keys():
if prompt_for_confirmation(
'Unrecognized tag name {0}, would you like to create it?'
.format(userinput), False):
label = card.board.add_label(userinput, 'black')
card.add_label(label)
click.echo(
'Successfully added tag {0} to board {1} and card {2}!'
.format(label.name, card.board.name, card.name))
label_choices = BoardTool.label_lookup(card.board)
label_completer = FuzzyWordCompleter(label_choices.keys())
else:
label_obj = label_choices[userinput]
try:
card.add_label(label_obj)
print('Added tag {0}'.format(Colors.green + userinput +
Colors.reset))
except trello.exceptions.ResourceUnavailable:
# This label already exists on the card so remove it
card.remove_label(label_obj)
print('Removed tag {0}'.format(Colors.red + userinput +
Colors.reset))
def select_document_prompt(docs):
while True:
print("Documents to choose from: ")
[print(doc) for doc in docs]
document_completer = FuzzyWordCompleter(docs)
selected_document = prompt("Select Document: ",
completer=document_completer)
if selected_document in docs:
return selected_document
else:
print("Invalid choice, try again.")
def get_completions(self, document: Document,
complete_event: CompleteEvent) -> Iterable[Completion]:
pattern = re.compile(r"^\w*$")
if not pattern.match(document.text.strip()):
return []
words = [
x.replace(self.path, "")
for x in glob.glob(self.path + document.text.strip() + self.glob)
]
return FuzzyWordCompleter(words=words, WORD=self.WORD).get_completions(
document, complete_event)
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 select_msm(client: InfluxDBClient):
rs: ResultSet = client.query('SHOW measurements')
msms = resp_list(list(rs.get_points()))
found_print('measurements', msms)
comp = FuzzyWordCompleter(msms)
msm = prompt(HTML(
'And what <ansicyan>measurement</ansicyan> contains crap (you can only choose one)?\n'
),
completer=comp,
complete_while_typing=True)
return msm
def test_fuzzy_completer():
collection = [
'migrations.py', 'django_migrations.py', 'django_admin_log.py',
'api_user.doc', 'user_group.doc', 'users.txt', 'accounts.txt',
'123.py', 'test123test.py'
]
completer = FuzzyWordCompleter(collection)
completions = completer.get_completions(Document('txt'), CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
completions = completer.get_completions(Document('djmi'), CompleteEvent())
assert [c.text for c in completions
] == ['django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('mi'), CompleteEvent())
assert [c.text for c in completions] == [
'migrations.py', 'django_migrations.py', 'django_admin_log.py'
]
completions = completer.get_completions(Document('user'), CompleteEvent())
assert [c.text for c in completions
] == ['user_group.doc', 'users.txt', 'api_user.doc']
completions = completer.get_completions(Document('123'), CompleteEvent())
assert [c.text for c in completions] == ['123.py', 'test123test.py']
completions = completer.get_completions(Document('miGr'), CompleteEvent())
assert [c.text for c in completions] == [
'migrations.py',
'django_migrations.py',
]
# Multiple words ending with space. (Accept all options)
completions = completer.get_completions(Document('test '), CompleteEvent())
assert [c.text for c in completions] == collection
# Multiple words. (Check last only.)
completions = completer.get_completions(Document('test txt'),
CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
def find_project_by_name(config):
"""
Implements search prompt to find project by name entered
by user. Uses fuzzy logic to match search with project names.
Parameters
----------
config : dict
Contains settings.
Returns
-------
str
Path to project selected by user based on his search.
"""
def get_possible_project_directories(config):
possible_directories = []
for projects_path in config['default_projects_paths']:
for root, dirs, files in os.walk(projects_path):
# modifying dirs directly to prune search tree
dirs[:] = filter_directories(dirs, config)
possible_directories.append(root)
return possible_directories
possible_directories = get_possible_project_directories(config)
parts = [os.path.split(d) for d in possible_directories]
projects_paths_dict = {project: path for path, project in parts}
completer = FuzzyWordCompleter(projects_paths_dict.keys(),
meta_dict=projects_paths_dict)
validator = Validator.from_callable(
lambda text: ' ' not in text,
error_message=('Spaces in project name? Really?'),
)
message = [('class:brackets', '['), ('class:question_mark', '?'),
('class:brackets', ']'), ('', ' Select project by name: ')]
try:
project = prompt(message,
completer=completer,
validator=validator,
validate_while_typing=True,
style=CustomTheme.get_prompt_style(),
color_depth=ColorDepth.ANSI_COLORS_ONLY)
except KeyboardInterrupt:
print('\nCancelled by user\n')
exit(0)
return os.path.join(projects_paths_dict[project], project)
def get_condition_session(client: InfluxDBClient, msm: str):
# TODO mode for mutli measurements
rs: ResultSet = client.query(f'SHOW TAG KEYS FROM {msm}')
tags = resp_list(list(rs.get_points()), 'tagKey')
found_print('tags', tags)
rs: ResultSet = client.query(f'SHOW FIELD KEYS FROM {msm}')
fields = resp_list(list(rs.get_points()), 'fieldKey')
found_print('fields', fields)
comp = FuzzyWordCompleter(['time'] + tags + fields)
session = PromptSession(HTML(
'Please choose a <ansicyan>condition WHERE</ansicyan> it is wrong:\n'),
completer=comp,
complete_while_typing=True,
auto_suggest=AutoSuggestFromHistory())
return session
def select_db(client: InfluxDBClient):
databases = resp_list(client.get_list_database())
found_print('databases', databases)
comp = FuzzyWordCompleter(databases)
db = prompt(HTML(
'Which <ansicyan>database</ansicyan> do you want to work on today?\n'),
completer=comp,
complete_while_typing=True)
if (db not in databases):
color_print(f'DB "{db}" does not exist, try to remember! (or hit TAB)',
'ansired')
return False
client.switch_database(db)
return True
def input_option(self, history_path, default="") -> str:
options = [option.value for option in list(AWSLogsOption)]
completer = FuzzyWordCompleter(options, WORD=True)
history = FileHistory(history_path)
session = PromptSession(history=history)
default = self.find_default_from_history(default, history)
option_str = session.prompt(
"Option : ",
completer=completer,
complete_while_typing=True,
default=default,
)
return option_str
def input_group(self, groups, history_path) -> str:
completer = FuzzyWordCompleter(groups, WORD=True)
history = FileHistory(history_path)
session = PromptSession(history=history)
default = self.find_recent_history(history)
group_name = session.prompt(
"Group : ",
completer=completer,
complete_while_typing=True,
default=default,
)
if group_name not in groups:
return ""
return group_name
def test_fuzzy_completer():
collection = [
'migrations.py',
'django_migrations.py',
'django_admin_log.py',
'api_user.doc',
'user_group.doc',
'users.txt',
'accounts.txt',
'123.py',
'test123test.py'
]
completer = FuzzyWordCompleter(collection)
completions = completer.get_completions(Document('txt'), CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
completions = completer.get_completions(Document('djmi'), CompleteEvent())
assert [c.text for c in completions] == ['django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('mi'), CompleteEvent())
assert [c.text for c in completions] == ['migrations.py', 'django_migrations.py', 'django_admin_log.py']
completions = completer.get_completions(Document('user'), CompleteEvent())
assert [c.text for c in completions] == ['user_group.doc', 'users.txt', 'api_user.doc']
completions = completer.get_completions(Document('123'), CompleteEvent())
assert [c.text for c in completions] == ['123.py', 'test123test.py']
completions = completer.get_completions(Document('miGr'), CompleteEvent())
assert [c.text for c in completions] == ['migrations.py', 'django_migrations.py',]
# Multiple words ending with space. (Accept all options)
completions = completer.get_completions(Document('test '), CompleteEvent())
assert [c.text for c in completions] == collection
# Multiple words. (Check last only.)
completions = completer.get_completions(Document('test txt'), CompleteEvent())
assert [c.text for c in completions] == ['users.txt', 'accounts.txt']
def prompt_enum(
enum_cls: Type[Enum],
for_attr: Optional[str] = None,
prompt_msg: Optional[str] = None,
dialog_title: str = "===",
) -> Enum:
m: str = create_prompt_string(str, for_attr, prompt_msg)
enum_mapping: Dict[str, Enum] = enum_attribute_dict(enum_cls)
enum_desc_map = _create_enum_word_targets(enum_mapping)
class EnumClosureValidator(Validator):
def __init__(self):
self.text = ""
def validate(self, document: Document) -> None:
# hmm; don't strip here since spaces might be part of the enum?
self.text = document.text
if self.text in enum_desc_map:
return
raise ValidationError(
message=f"{self.text} is not part of the {enum_cls} enum")
def toolbar(self):
if self.text in enum_desc_map:
return str(enum_desc_map[self.text])
else:
return "..."
validator = EnumClosureValidator()
# prompt using a repl prompt with autocompletion/validation
resp = prompt(
m,
completer=FuzzyWordCompleter(words=list(enum_desc_map)),
validator=validator,
bottom_toolbar=validator.toolbar,
)
# use what the user typed
if resp in enum_desc_map:
return enum_desc_map[resp]
# else lowercase
return enum_desc_map[resp.casefold()]
def _runConfigurationWizard(setups, defaultSetup):
"""The implementation of the configuration wizard"""
from prompt_toolkit import prompt, print_formatted_text, HTML
from prompt_toolkit.completion import FuzzyWordCompleter
# It makes no sense to have suggestions if there is no default so adjust the message accordingly
msg = ""
if setups:
msg = "press tab for suggestions"
if defaultSetup:
msg = "default</b> <green>%s</green><b>, %s" % (defaultSetup, msg)
msg = " (%s)" % msg
# Get the Setup
setup = prompt(
HTML("<b>Choose a DIRAC Setup%s:</b>\n" % msg),
completer=FuzzyWordCompleter(list(setups)),
)
if defaultSetup and not setup:
setup = defaultSetup
if setup not in setups:
print_formatted_text(
HTML("Unknown setup <yellow>%s</yellow> chosen" % setup))
confirm = prompt(HTML("<b>Are you sure you want to continue?</b> "),
default="n")
if confirm.lower() not in ["y", "yes"]:
return None
# Get the URL to the master CS
csURL = prompt(
HTML(
"<b>Choose a configuration server URL (leave blank for default):</b>\n"
))
if not csURL:
csURL = setups[setup]
# Confirm
print_formatted_text(
HTML("<b>Configuration is:</b>\n" +
" * <b>Setup:</b> <green>%s</green>\n" % setup +
" * <b>Configuration server:</b> <green>%s</green>\n" % csURL))
confirm = prompt(HTML("<b>Are you sure you want to continue?</b> "),
default="y")
if confirm.lower() in ["y", "yes"]:
return setup, csURL
def input_command(self) -> str:
commands = [command.name for command in list(AWSLogsCommand)]
completer = FuzzyWordCompleter(commands)
history = FileHistory(
self.alw_path.create_filepath(self.COMMAND_HISTORY_NAME))
session = PromptSession(history=history)
default = self.find_recent_history(history)
command_str = session.prompt(
"Command: ",
completer=completer,
complete_while_typing=True,
default=default,
)
if command_str not in commands:
return ""
return command_str
def input_profile(self, default="") -> str:
profiles = ProfileConfig.load_profiles(self.AWS_CRED_PATH)
completer = FuzzyWordCompleter(profiles, WORD=True)
history = FileHistory(
self.alw_path.create_filepath(self.PROFILE_HISTORY_NAME))
session = PromptSession(history=history)
default = self.find_default_from_history(default, history)
profile = session.prompt(
"Profile: ",
completer=completer,
complete_while_typing=True,
default=default,
)
if profile not in profiles:
return ""
return profile
class FirstWordFuzzyWordCompleter(Completer):
def __init__(self,
words: Union[List[str], Callable[[], List[str]]],
meta_dict: Optional[Dict[str, str]] = None,
WORD: bool = False) -> None:
self.words = words
self.meta_dict = meta_dict or {}
self.WORD = WORD
self.fuzzy_word_completer = FuzzyWordCompleter(words=self.words,
WORD=self.WORD)
def get_completions(self, document: Document,
complete_event: CompleteEvent) -> Iterable[Completion]:
pattern = re.compile(r"^\w*$")
if not pattern.match(document.text.strip()):
return []
return self.fuzzy_word_completer.get_completions(
document, complete_event)
