def __init__(self, pseudo = "user", jeu = "p4", ami_anonyme="ami"):
self.pseudo = pseudo
self.game = jeu.lower()
self.ami_anonyme = ami_anonyme.lower()
if ami_anonyme == "ami":
self.questions = [
{
'type' : 'list',
'name' : 'menu_Salle',
'message' : "Que souhaitez-vous faire ?",
'choices' : [
'Créer une salle',
'Rejoindre une salle',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
elif ami_anonyme == "anonyme":
self.questions = [
{
'type' : 'list',
'name' : 'menu_Salle',
'message' : "Que souhaitez-vous faire ?",
'choices' : [
'Jouer contre des inconnus',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
def _ask_and_set_metadata_details(self):
questions = [{
'type':
'checkbox',
'message':
'Select meta data details',
'name':
'metadata_details',
'choices': [
PyInquirer.Separator('= Tag options ='),
{
'name': 'Spaces in tags',
'checked': self._default_settings.spaces_in_tags
},
{
'name': 'Split tags',
'checked': self._default_settings.split_tags
},
],
}]
answers = prompt(questions, style=self.style)
_exit_if_keyboard_interrupt(answers)
if 'Spaces in tags' in answers['metadata_details']:
self._cli_conversion_settings.spaces_in_tags = True
if 'Split tags' in answers['metadata_details']:
self._cli_conversion_settings.split_tags = True
def _ask_and_set_chart_options(self):
questions = [{
'type':
'checkbox',
'message':
'Select chart options',
'name':
'chart_options',
'choices': [
PyInquirer.Separator('= Chart Options ='),
{
'name': 'Include an image of chart',
'checked': self._default_settings.chart_image
},
{
'name': 'Include a csv file of chart data',
'checked': self._default_settings.chart_csv
},
{
'name': 'Include a data table of chart data',
'checked': self._default_settings.chart_data_table
},
],
}]
answers = prompt(questions, style=self.style)
_exit_if_keyboard_interrupt(answers)
self._cli_conversion_settings.chart_image = 'Include an image of chart' in answers[
'chart_options']
self._cli_conversion_settings.chart_csv = 'Include a csv file of chart data' in answers[
'chart_options']
self._cli_conversion_settings.chart_data_table = 'Include a data table of chart data' \
in answers['chart_options']
def _ask_and_set_table_details(self):
questions = [{
'type':
'checkbox',
'message':
'Select table options',
'name':
'table_options',
'choices': [
PyInquirer.Separator('= Table Options ='),
{
'name': 'First row of table as header row',
'checked': self._default_settings.first_row_as_header
},
{
'name': 'First column of table as header column',
'checked': self._default_settings.first_column_as_header
},
],
}]
answers = prompt(questions, style=self.style)
_exit_if_keyboard_interrupt(answers)
if 'First row of table as header row' in answers['table_options']:
self._cli_conversion_settings.first_row_as_header = True
if 'First column of table as header column' in answers[
'table_options']:
self._cli_conversion_settings.first_column_as_header = True
def get_target(inventory):
inv_groups = sorted(inventory.groups.values(), key=lambda x: x.name)
inv_hosts = sorted(inventory.hosts.values(), key=lambda x: x.name)
if len(inv_hosts) == 0:
sys.exit("ERROR: Host list is empty")
choices = [PyInquirer.Separator("==== Groups ====")]
choices.extend([{
"name": f" [{group.name}]",
"value": group
} for group in inv_groups])
choices.append(PyInquirer.Separator("==== Hosts ===="))
choices.extend([{
"name": f" {host.name}",
"value": host
} for host in inv_hosts])
return common.select_from_list(
"Select a group or a host (Ctrl+C to cancel)", choices)
def getAsvTables(pw):
os.chdir(pw.pd)
csvs = glob.glob("*.csv", recursive=True)
chooseNth = 1
include = []
if args.interactive:
while chooseNth > 0:
if chooseNth == 1:
question = "Please choose the first table to include"
else:
question = "Please choose the next table to include"
questions = [{
"type":
"list",
"name":
"selection",
"message":
question,
"choices":
csvs + [PyInquirer.Separator(), "Abort", "Done"],
}]
selected = PyInquirer.prompt(
questions, style=examples.custom_style_2)["selection"]
if selected == "Abort":
sys.exit(0)
elif selected == "Done":
chooseNth = 0
else:
include.append(selected)
i = csvs.index(selected)
csvs = csvs[0:i] + csvs[i + 1:]
# Remember which ASV table was chosen first
if chooseNth == 1:
opts["defaultAsvTable"] = selected
chooseNth += 1
print("\n")
else:
include = glob.glob(pw.proj("*asvs+taxa*.csv"),
recursive=True) + glob.glob(
pw.proj("*taxa-merged*.csv"), recursive=True)
for file in include:
opts["asvDfs"][file] = readAsvTable(pw.proj(file))
return True
def prompt_group(self, group_id, group_obj):
"""
Prompt for edits to a group of parameters (subschema in 'definitions')
Args:
group_id: Paramater ID (string)
group_obj: JSON Schema keys (dict)
Returns:
Dict of param_id:val answers
"""
question = {
"type": "list",
"name": group_id,
"message": group_obj.get("title", group_id),
"choices": ["Continue >>", PyInquirer.Separator()],
}
for param_id, param in group_obj["properties"].items():
if not param.get("hidden", False) or self.show_hidden:
question["choices"].append(param_id)
# Skip if all questions hidden
if len(question["choices"]) == 2:
return {}
while_break = False
answers = {}
while not while_break:
self.print_param_header(group_id, group_obj)
answer = PyInquirer.prompt([question])
# TODO: use raise_keyboard_interrupt=True when PyInquirer 1.0.3 is released
if answer == {}:
raise KeyboardInterrupt
if answer[group_id] == "Continue >>":
while_break = True
# Check if there are any required parameters that don't have answers
for p_required in group_obj.get("required", []):
req_default = self.schema_obj.input_params.get(
p_required, "")
req_answer = answers.get(p_required, "")
if req_default == "" and req_answer == "":
log.error("'{}' is required.".format(p_required))
while_break = False
else:
param_id = answer[group_id]
is_required = param_id in group_obj.get("required", [])
answers.update(
self.prompt_param(param_id,
group_obj["properties"][param_id],
is_required, answers))
return answers
def interactive_validation(args, validation_json):
"""Derived from https://codeburst.io/building-beautiful-command-line-interfaces-with-python-26c7e1bb54df"""
style = PyInquirer.style_from_dict({
PyInquirer.Token.Separator: "#cc5454",
PyInquirer.Token.QuestionMark: "#673ab7 bold",
PyInquirer.Token.Selected: "#cc5454", # default
PyInquirer.Token.Pointer: "#673ab7 bold",
PyInquirer.Token.Instruction: "", # default
PyInquirer.Token.Answer: "#f44336 bold",
PyInquirer.Token.Question: "",
})
answers = {}
questions = [
{
"type": "input",
"name": "hostname",
"message": "Device hostname to validate against?",
},
{
"type":
"list",
"name":
"device_type",
"message":
"Device type?", # https://github.com/ncclient/ncclient#supported-device-handlers
"choices": [
"default",
PyInquirer.Separator("= Cisco ="),
"csr",
"nexus",
"iosxr",
"iosxe",
PyInquirer.Separator("= Juniper ="),
"junos",
PyInquirer.Separator("= Huawei ="),
"huawei",
"huaweiyang",
PyInquirer.Separator("= Alcatel Lucent ="),
"alu",
PyInquirer.Separator("= H3C ="),
"h3c",
PyInquirer.Separator("= HP Comware ="),
"hpcomware",
],
},
{
"type": "input",
"name": "username",
"message": "Username?"
},
{
"type": "password",
"name": "password",
"message": "Password?"
},
]
answers = PyInquirer.prompt(questions, style=style)
return validate_online(validation_json, **answers)
def __init__(self):
self.questions = [
{
'type':
'list',
'name':
'choix_Jeu_Anonyme',
'message':
"A quel jeu souhaitez-vous jouer ?",
'choices': [
'Le jeu de l\'oie', 'Le puissance 4',
inquirer.Separator(), 'Revenir au menu précédent'
]
},
]
def __init__(self, pseudo = "user"):
self.questions = [
{
'type' : 'list',
'name' : 'menu_Modif_Info',
'message' : "Que souhaitez-vous faire ?",
'choices' : [
'Modifier mon pseudo',
'Modifier mon mot de passe',
'Accéder à ses statistiques personnelles',
'Réinitialiser ses statistiques personnelles',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
self.pseudo = pseudo
def prompt_send_revise_skip(
file: File, source: Union[MediaName, MediaNameParse,
QueryResult]) -> bool:
print_media_summary(file=file, source=source)
choices = [
'Manually Enter Information', 'Skip File',
PyInquirer.Separator(), 'Quit'
]
if file.destination_directory and file.destination_filename:
choices.insert(0, 'Send to Media Library')
question = dict(
type='list',
name='send',
message='Choose to send, revise, or skip',
choices=choices,
)
answer = PyInquirer.prompt(question)
return answer.get('send')
def __init__(self, pseudo="user"):
self.questions = [
{
'type':
'list',
'name':
'Menu_Co',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Jouer',
'Accéder au profil',
inquirer.Separator(),
'Se déconnecter',
]
},
]
self.pseudo = pseudo
def __init__(self, pseudo):
self.questions = [
{
'type':
'list',
'name':
'menu_Profil',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Accéder à mes informations personnelles',
'Accéder à ma liste d\'amis',
'Accéder aux classements',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
self.pseudo = pseudo
def __init__(self, pseudo="user"):
self.questions = [
{
'type':
'list',
'name':
'menu_Classement',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Afficher le classement général',
'Afficher le classement du jeu de l\'oie',
'Afficher le classement du puissance 4',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
self.pseudo = pseudo
def __init__(self, pseudo="user"):
self.questions = [
{
'type':
'list',
'name':
'menu_Ami',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Ajouter un ami',
'Supprimer un ami',
'Afficher ma liste d\'amis',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
self.pseudo = pseudo
def __init__(self, pseudo="user", jeu="p4"):
self.questions = [
{
'type':
'list',
'name':
'menu_Choix_Mode_Jeu_Connecte',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Jouer avec des amis',
'Jouer contre des inconnus selon les règles officielles',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
self.pseudo = pseudo
self.game = jeu.lower()
def __init__(self, jeu="p4"):
self.questions = [
{
'type':
'list',
'name':
'menu_Choix_Mode_Jeu_Anonyme',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Jouer contre des inconnus selon les règles officielles',
inquirer.Separator(),
'Revenir au menu précédent',
]
},
]
if jeu.lower() == "oie":
self.game = "Jeu de l'Oie"
elif jeu.lower() == "p4":
self.game = "Puissance 4"
else:
self.game = "erreur sur le jeu"
def __init__(self, pseudo, id_salle, jeu, est_chef):
self.pseudo = pseudo.lower()
self.game = jeu.lower()
self.id_salle = id_salle
self.est_chef = est_chef
self.question = [
{
'type':
'list',
'name':
'Salon_accueil',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Voir les membres de la salle',
#'Modifier les paramètres de la salle',
'Lire les règles',
"Être prêt",
inquirer.Separator(),
'Quitter la salle',
]
},
]
def prompt_group(self, param_id, param_obj):
"""Prompt for edits to a group of parameters
Only works for single-level groups (no nested!)
Args:
param_id: Paramater ID (string)
param_obj: JSON Schema keys - no objects (dict)
Returns:
Dict of param_id:val answers
"""
question = {
'type': 'list',
'name': param_id,
'message': param_id,
'choices': ['Continue >>', PyInquirer.Separator()]
}
for child_param, child_param_obj in param_obj['properties'].items():
if (child_param_obj['type'] == 'object'):
logging.error("nf-core only supports groups 1-level deep")
return {}
else:
if not child_param_obj.get('hidden',
False) or self.show_hidden:
question['choices'].append(child_param)
# Skip if all questions hidden
if len(question['choices']) == 2:
return {}
while_break = False
answers = {}
while not while_break:
self.print_param_header(param_id, param_obj)
answer = PyInquirer.prompt([question],
raise_keyboard_interrupt=True)
if answer[param_id] == 'Continue >>':
while_break = True
# Check if there are any required parameters that don't have answers
if self.schema_obj is not None and param_id in self.schema_obj.schema[
'properties']:
for p_required in self.schema_obj.schema['properties'][
param_id].get('required', []):
req_default = self.schema_obj.input_params.get(
p_required, '')
req_answer = answers.get(p_required, '')
if req_default == '' and req_answer == '':
click.secho(
"Error - '{}' is required.".format(p_required),
fg='red',
err=True)
while_break = False
else:
child_param = answer[param_id]
is_required = child_param in param_obj.get('required', [])
answers.update(
self.prompt_param(child_param,
param_obj['properties'][child_param],
is_required, answers))
return answers
def make_choice(self):
if self.game == "p4":
self.questions_parametre_partie_perso = [
{
'type':
'list',
'name':
'menu_Param_Perso',
'message':
"Quel paramètre souhaitez-vous modifier ?",
'choices': [
'Durée des tours',
'Condition de victoire',
'Taille du plateau',
inquirer.Separator(),
'Sauvegarder les paramètres et revenir au salon',
'Abandonner et revenir au salon',
]
},
]
while True:
self.reponse_partie_perso = inquirer.prompt(
self.questions_parametre_partie_perso)
if self.reponse_partie_perso[
"menu_Param_Perso"] == "Durée des tours":
questions_tour_perso = [
{
'type':
'list',
'name':
'menu_Tour_Perso',
'message':
"Veuilliez choisir la durée d'un tour.",
'choices': [
'10 secondes',
'15 secondes',
'20 secondes',
]
},
]
self.parametre["duree_tour"] = inquirer.prompt(
questions_tour_perso)["menu_Tour_Perso"]
elif self.reponse_partie_perso[
"menu_Param_Perso"] == "Condition de victoire":
questions_Cond_Vict_perso = [
{
'type': 'list',
'name': 'menu_Cond_Vict_Perso',
'message':
"Veuilliez choisir le nombre de jetons à aligner pour remporter la partie.",
'choices': [
'3',
'4',
'5',
]
},
]
self.parametre["condition_victoire"] = \
inquirer.prompt(questions_Cond_Vict_perso)["menu_Cond_Vict_Perso"]
elif self.reponse_partie_perso[
"menu_Param_Perso"] == "Taille du plateau":
questions_Taille_Plateau_perso = [
{
'type': 'list',
'name': 'menu_Taille_Plateau_Perso',
'message':
"Veuilliez choisir la taille du plateau.",
'choices': [
'6 x 5',
'7 x 6',
'8 x 7',
]
},
]
self.parametre["Taille_plateau"] = \
inquirer.prompt(questions_Taille_Plateau_perso)["menu_Taille_Plateau_Perso"]
elif self.reponse_partie_perso[
"menu_Param_Perso"] == "Sauvegarder les paramètres et revenir au salon":
self.creer_partie_perso_P4()
elif self.reponse_partie_perso[
"menu_Param_Perso"] == "Abandonner et revenir au salon":
import Vues.menu_Salon as MS
retour = MS.Salon(self.pseudo, self.id_salle, self.game,
self.est_chef)
retour.display_info()
return retour.make_choice()