def prompt_transfer_networks(self):
"""Prompt user to choose 2 networks between registered bridged
networks.
"""
networks = self.get_registered_networks()
questions = [{
'type': 'list',
'name': 'from_chain',
'message': 'Departure network',
'choices': networks
}]
answers = inquirer.prompt(questions, style=aergo_style)
from_chain = answers['from_chain']
networks = [
net for net in self.wallet.config_data('networks', from_chain,
'bridges')
]
if len(networks) == 0:
raise InvalidArgumentsError('No bridge registered to this network')
questions = [{
'type': 'list',
'name': 'to_chain',
'message': 'Destination network',
'choices': networks
}]
answers = inquirer.prompt(questions, style=aergo_style)
to_chain = answers['to_chain']
return from_chain, to_chain
def prompt_bridge_networks(self):
"""Prompt user to choose 2 networks between registered networks."""
networks = self.get_registered_networks()
questions = [
{
'type': 'list',
'name': 'from_chain',
'message': 'Departure network',
'choices': networks
}
]
answers = inquirer.prompt(questions, style=aergo_style)
from_chain = answers['from_chain']
networks.remove(from_chain)
questions = [
{
'type': 'list',
'name': 'to_chain',
'message': 'Destination network',
'choices': networks
}
]
answers = inquirer.prompt(questions, style=aergo_style)
to_chain = answers['to_chain']
return from_chain, to_chain
def query_unit(units: typing.Dict[str, int]) -> typing.Optional[str]:
"""Query a name of a unit from the user."""
answer = PyInquirer.prompt({
"type": "input",
"name": "unit",
"message": "Enter name of unit:"
})
unit = answer.get("unit")
if unit is None:
return None
def get_matches(unit):
num_matches, cutoff = 4, 0.0
return difflib.get_close_matches(unit, units, num_matches, cutoff)
matches = get_matches(unit)
choices = [dict(name=match) for match in matches]
answer = PyInquirer.prompt({
"type": "list",
"message": "Select match:",
"name": "unit",
"choices": choices,
})
unit = answer.get("unit")
return unit
def user_confirms_cleartext(no_warning):
import PyInquirer as inq
if no_warning:
return True
answers = inq.prompt(
{
"type":
"confirm",
"name":
"continuing",
"message":
("Output may include passwords or keys stored as cleartext " +
"in laforge build INIs, configs, or .envs. Continue?"),
"default":
False,
"qmark":
"WARNING:",
},
style=inq.style_from_dict({
inq.Token.QuestionMark: "#cd422d bold",
inq.Token.Question: "#cd422d"
}),
)
return answers.get("continuing", False)
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 login():
answers = PyInquirer.prompt(questions[Questions.LOGIN])
if answers[Questions.LOGIN.name] == 'Sign in':
q_user = Questions.USERNAME
q_pw = Questions.PASSWORD
url = API_ENDPOINT + 'token/'
else:
q_user = Questions.CREATE_USERNAME
q_pw = Questions.CREATE_PASSWORD
url = API_ENDPOINT + 'users/sign_up/'
answers.update(PyInquirer.prompt([questions[q_user], questions[q_pw]]))
data = {'username': answers[q_user.name], 'password': answers[q_pw.name]}
res = requests.post(url=url, data=data)
res_dict = res.json()
if res.status_code != requests.codes.ok and res.status_code != requests.codes.created:
for key in res_dict.keys():
for value in res_dict[key]:
print('Error: ' + value)
sys.exit(0)
try:
return res_dict["token"]
except KeyError:
url = API_ENDPOINT + 'token/'
res = requests.post(url=url, data=data)
res_dict = res.json()
return res_dict["token"]
def ask_for_fields(self, entity):
fields = entity.fields
fields = {k: v for (k, v) in fields.items() if v is not "relationship"}
questions = map(lambda f: PyInquirer.Text(f, message="{}".format(f)),
fields)
answers = PyInquirer.prompt(questions)
logging.debug("Creating entity (%s) with values %s", entity, answers)
for field, value in answers.items():
setattr(entity, field, value)
def run(self, *args):
if len(args) < 1:
return self.help()
entity_name = args[0]
entity = self.entity_manager.get_entity(entity_name)
logging.debug("EM: %s", self.entity_manager)
logging.debug("Available entities: %s",
self.entity_manager.get_all_entities())
if not entity:
print("Couldn't find the class you are looking for")
return self.help()
entity = entity()
print("New {}:\n\n".format(entity_name))
self.ask_for_fields(entity)
for name, relationship in entity.relationships.items():
if isinstance(relationship, ManyToMany):
pass
# Do something for many to many
elif isinstance(relationship, OneToMany):
#get all remote entities
available_data = list(relationship.find_all())
available_data = list(
map(lambda x: (x.render_excerpt(), x), available_data))
logging.debug(available_data)
questions = [
PyInquirer.Checkbox(
"relation",
message="Which {}?".format(name),
choices=available_data,
)
]
res = PyInquirer.prompt(questions)
logging.debug(res)
setattr(entity, name, res["relation"])
elif isinstance(relationship, OneToOne):
#get all remote entities
available_data = list(relationship.find_all())
available_data = list(
map(lambda x: (x.render_excerpt(), x), available_data))
logging.debug(available_data)
questions = [
PyInquirer.List(
"relation",
message="Which {}?".format(name),
choices=available_data,
)
]
res = PyInquirer.prompt(questions)
logging.debug(res)
setattr(entity, name, res["relation"])
#TODO add resume plus confirm
entity.save()
print("New {} {} created succesfully".format(entity_name, entity.id))
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, module_parser):
"""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 = {}
def get_os_releases(answers):
return sorted(
list(module_parser.os_release_prod_map[answers["os"]]
["releases"].keys()),
reverse=True,
)
def get_os_release_products(answers):
return sorted(["None"] + list(module_parser.os_release_prod_map[
answers["os"]]["releases"][answers["release"]]["products"].keys()))
questions = [
{
"type": "list",
"name": "os",
"message": "Which OS to validate against?",
"choices": sorted(list(module_parser.os_release_prod_map.keys())),
"filter": lambda val: val.lower(),
},
{
"type": "list",
"name": "release",
"message": "Which Release of OS?",
"choices": get_os_releases,
},
{
"type": "list",
"name": "product",
"message": "Which Product of OS - Release?",
"choices": get_os_release_products,
},
]
answers = PyInquirer.prompt(questions, style=style)
return validate_product(
module_parser,
validation_json,
answers["os"],
answers["release"],
None if answers["product"] == "None" else answers["product"],
)
def prompt(questions, style=None):
"""Wrapper for Pyinquirer prompt, includes app exit functionality
Parameters
----------
question: dict, list
Iterator containing dictionaries of questions
style: dict
Style information for styling the command prompt text
Returns
-------
value: dict
Chosen value(s) for the question(s).
"""
if style != None:
if not isinstance(style, dict):
raise TypeError("Style Data Can Only Be A Dictionary")
while True:
if isinstance(questions, dict):
questions = [questions]
elif isinstance(questions, list):
for question in questions:
if not isinstance(question, dict):
raise TypeError("Must Be List Of Dictionaries")
else:
message = "Invalid Datatype, Supports Dictionaries or List of Dictionaries"
raise Exception(message)
if style is not None:
value = PyInquirer.prompt(questions, style=style)
else:
value = PyInquirer.prompt(questions)
if len(value) != len(questions):
dictionary_length = len(value)
current_question = questions[dictionary_length]
if current_question["message"] == "Exit Application":
print("Exiting Application")
sys.exit()
exit_prompt = inquirer_confirm("Exit Application", True)
if exit_prompt:
print("Exiting Application")
sys.exit()
else:
break
return value
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 menu_modif_mdp(self):
self.mdpQ = [
{
'type' : 'password',
'name' : 'Old_Password',
'message' : "Veuillez insérer votre mot de passe actuel : ",
},
{
'type': 'password',
'name': 'New_Password',
'message': "Veuillez insérer votre nouveau mot de passe : ",
},
{
'type': 'password',
'name': 'Password_Check',
'message': "Veuillez confirmer votre nouveau mot de passe : ",
},
]
while True:
self.mdpR = inquirer.prompt(self.mdpQ)
old_mdp = self.mdpR["Old_Password"]
new_mdp1, new_mdp2 = self.mdpR["New_Password"], self.mdpR["Password_Check"]
from Player.UserClass import User
User1 = User(self.pseudo)
Resultat = User1.modifier_mdp(old_mdp,new_mdp1,new_mdp2)
self.print_message(Resultat)
if Resultat["Statut"] == True:
return (self.make_choice())
elif Resultat["Statut"] == False:
return (self.menu_echec_modif_mdp())
else:
print("Erreur non prévue")
return (self.menu_echec_modif_mdp())
def menu_reinit_stat_perso(self):
self.Verif_choixQ = [
{
'type': 'list',
'name': 'Retour',
'message': "Etes-vous sûr.e de vouloir réinitialiser vos statistiques personnelles ?",
'choices': [
'Oui',
'Non',
]
},
]
while True:
self.Verif_choixR = inquirer.prompt(self.Verif_choixQ)
if self.Verif_choixR["Retour"] == "Non" :
print("Abandon")
return self.make_choice()
elif self.Verif_choixR["Retour"] == "Oui" :
from Player.UserClass import User
User1 = User(self.pseudo)
Resultat = User1.reinitialiser_stats_perso()
self.print_message(Resultat)
if Resultat["Statut"] == True:
return (self.make_choice())
elif Resultat["Statut"] == False:
return (self.make_choice())
else:
print("Erreur non prévue")
return (self.make_choice())
else:
print("erreur non prévue : " + str(res.status_code))
return(self.make_choice())
def menu_modif_pseudo(self):
self.mdpQ = [
{
'type' : 'input',
'name' : 'New_Pseudo',
'message' : "Veuillez insérer votre nouveau pseudo : ",
},
]
while True:
print(f"Votre pseudo actuel est {self.pseudo}.")
self.mdpR = inquirer.prompt(self.mdpQ)
new_pseudo = self.mdpR["New_Pseudo"].lower()
from Player.UserClass import User
User1 = User(self.pseudo)
Resultat = User1.modifier_pseudo(new_pseudo)
self.print_message(Resultat)
if Resultat["Statut"] == True:
self.pseudo = new_pseudo
return(self.make_choice())
elif Resultat["Statut"] == False:
return(self.menu_echec_modif_pseudo())
else:
print("Erreur non prévue")
return (self.menu_echec_modif_pseudo())
def select_box_file(batch_mode):
box_files = sorted(pathlib.Path().rglob("*.box"))
if len(box_files) == 0:
sys.exit(
"Can't find any *.box files in current directory and subdirectories"
)
if len(box_files) == 1:
return str(box_files[0])
if batch_mode:
sys.exit(
"More than one box file has been found. Will not display selection "
"dialog in batch mode")
answers = PyInquirer.prompt(questions=[{
'type':
'list',
'name':
'boxfile',
'message':
'Select a box file to publish',
'choices': [str(i) for i in box_files]
}],
keyboard_interrupt_msg="")
if not answers:
sys.exit("Cancelled by user")
return str(answers["boxfile"])
def get_box_description(batch_mode, is_new_box):
box_description = ""
if os.path.isfile("box_description.md"):
print("Reading box description from 'box_description.md'")
with open("box_description.md", "r") as desc_f:
box_description = desc_f.read().strip("\n")
# For a newly created box there has to be a description
if is_new_box:
if not box_description:
if batch_mode:
sys.exit(
"'box_description.md' is missing. Will not create a new box "
"without a description in batch mode")
answers = PyInquirer.prompt(questions=[{
"type": "editor",
"name": "box_description",
"message":
"Please enter box description (Alt+Enter to finish)\n",
"default": box_description
}],
keyboard_interrupt_msg="")
if not answers:
sys.exit("Cancelled by user")
box_description = answers["box_description"]
return box_description
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 menu_echec_ajout_ami(self):
self.echecAjoutAmiQ = [
{
'type':
'list',
'name':
'Retour',
'message':
"Que souhaitez-vous faire ?",
'choices': [
'Réessayer',
'Retourner au menu de la liste des amis',
]
},
]
while True:
self.echecAjoutAmiR = inquirer.prompt(self.echecAjoutAmiQ)
if self.echecAjoutAmiR["Retour"] == "Réessayer":
return self.menu_ajout_ami()
elif self.echecAjoutAmiR[
"Retour"] == "Retourner au menu de la liste des amis":
return self.make_choice()
else:
print("Erreur dans echec_ajout_ami")
break
def make_choice_retour(self):
self.questions_retour = [
{
'type': 'list',
'name': 'Retour',
'message': "Que souhaitez-vous faire ?",
'choices': [
'Réessayer',
'Retourner à l\'accueil',
]
},
]
while True:
self.reponse_retour = inquirer.prompt(self.questions_retour)
if self.reponse_retour['Retour'] == "Réessayer":
return self.make_choice()
elif self.reponse_retour['Retour'] == "Retourner à l'accueil":
import Vues.menu_Accueil as MA
Retour = MA.Menu_Accueil()
Retour.display_info()
return Retour.make_choice()
else:
print(
"Erreur dans menu_Creer_Comtpe.Menu_CreerCompte.make_choice_retour"
)
break
def make_choice(self):
self.questions = [{
'type': 'input',
'name': 'identifiant',
'message': "Veuillez insérer votre identifiant",
}, {
'type': 'password',
'name': 'Password',
'message': "Veuillez insérer votre mot de passe",
}, {
'type': 'password',
'name': 'password_Check',
'message': "Veuillez confirmer votre mot de passe",
}, {
'type': 'input',
'name': 'pseudo',
'message': "Veuillez insérer votre pseudo",
}]
while True:
self.reponse = inquirer.prompt(self.questions)
from Player.UserBaseClass import UserBase
UserBase1 = UserBase()
Resultat = UserBase1.creer_compte(
self.reponse["identifiant"].lower(), self.reponse["Password"],
self.reponse["password_Check"], self.reponse["pseudo"].lower())
self.print_message(Resultat)
if Resultat["Statut"] == False:
return (self.make_choice_retour())
elif Resultat["Statut"] == True:
import Vues.menu_Connexion as MC
Co = MC.Menu_Connexion()
Co.display_info()
return Co.make_choice()
def menu_retour(self):
self.question_retour = [
{
'type': 'list',
'name': 'salon_retour',
'message':
f"Vous allez retourner au menu précédant. Vous allez donc quitter la salle {self.id_salle}. Etes vous sur? ",
'choices': ["Oui", "Non"]
},
]
while True:
self.reponse_retour = inquirer.prompt(self.question_retour)
if self.reponse_retour["salon_retour"] == "Oui":
Player1 = Player(self.pseudo, self.game, self.id_salle,
self.est_chef)
Resultat = Player1.quitter_salle()
self.print_message(Resultat)
if Resultat["Statut"]:
import Vues.menu_Choix_Mode_Jeu as MCMJ
Retour = MCMJ.Menu_Choix_Mode_Jeu_Connecte(
pseudo=self.pseudo, jeu=self.game)
Retour.display_info()
return Retour.make_choice()
elif not Resultat["Statut"]:
return self.make_choice()
else:
print("Erreur non prévue")
return self.make_choice()
else: #'non'
return self.make_choice()
def make_choice(self):
while True:
self.reponse = inquirer.prompt(self.question)
if self.reponse["Salon_accueil"] == 'Voir les membres de la salle':
return self.menu_voir_membres_salle()
elif self.reponse[
"Salon_accueil"] == 'Modifier les paramètres de la salle':
import Vues.menu_Parametres as MPara
MParametre1 = MPara.Menu_Parametre(self.pseudo, self.id_salle,
self.game, self.est_chef)
return MParametre1.make_choice()
elif self.reponse["Salon_accueil"] == 'Lire les règles':
if self.game.lower() == 'p4':
with codecs.open("Vues/Affichagetxt/règles/p4_rules.txt",
"r", 'UTF-8') as rules:
print(rules.read())
elif self.game.lower() == 'oie':
with codecs.open("Vues/Affichagetxt/règles/oie_rules.txt",
"r", 'UTF-8') as rules:
print(rules.read())
return self.make_choice()
elif self.reponse["Salon_accueil"] == "Être prêt":
self.choix_couleur(self.get_liste_couleurs_dispo())
if self.est_chef == True:
self.etre_pret_chef()
else:
self.etre_pret()
Action = Play.Jouer(self.pseudo, self.id_salle, self.game,
self.est_chef)
return Action.jouer()
else: #'Quitter la salle'
return self.menu_retour()
break
def make_choice_retour(self):
self.questions_retour = [
{
'type': 'list',
'name': 'Retour',
'message': "Que souhaitez-vous faire ?",
'choices': [
'Réessayer',
'Revenir au menu precedent',
]
},
]
while True:
self.reponse_retour = inquirer.prompt(self.questions_retour)
if self.reponse_retour['Retour'] == "Réessayer":
return self.make_choice()
elif self.reponse_retour['Retour'] == "Revenir au menu precedent":
import Vues.menu_Profil as MP
Retour = MP.Menu_Accueil()
Retour.display_info()
return Retour.make_choice()
else:
print(
"Erreur dans menu_Classement.Menu_Classement.make_choice_retour"
)
break
def download_ui(user):
global SYNOLOGY_GLOBALS
wd = Path(SYNOLOGY_GLOBALS["START_PATH"])
while True:
try:
tree = get_remote_tree(user, wd)
except ConnectionError as e:
print(e)
return
# choices.sort()
mode_change = "DIRECTORY DOWNLOAD MODE" if SYNOLOGY_GLOBALS[
"MODE"] == Mode.BROWSE else "BROWSE MODE"
tree = ["CANCEL", mode_change] + tree[1:len(tree)]
questions = [{
'type': 'list',
'name': 'chooser',
'message': "MODE: " + SYNOLOGY_GLOBALS["MODE"].name,
'choices': tree,
}]
choice = PyInquirer.prompt(questions,
style=examples.custom_style_2)['chooser']
def process_directory(fullpath):
nonlocal wd
if SYNOLOGY_GLOBALS["MODE"] == Mode.BROWSE:
wd = fullpath
if SYNOLOGY_GLOBALS["MODE"] == Mode.DIRECTORY_DOWNLOAD:
ask_download(user, fullpath, "directory")
# FILE
if choice[0] == "-":
basename = choice.split()[8]
fullname = wd / Path(basename)
ask_download(user, fullname, "file")
if choice[0] == "l":
# Determine if symlink is to directory or file
target = Path(choice.split()[8]).resolve()
if target.is_dir():
process_directory(target)
else:
ask_download(user, target, "file")
# GO BACK TO MAIN MENU
elif choice == "CANCEL":
break
# DIRECTORY -> navigate to that directory, with . and .. resolution
elif choice[0] == 'd':
basename = choice.split()[8]
fullpath = (wd / Path(basename)).resolve()
process_directory(fullpath)
elif choice == "DIRECTORY DOWNLOAD MODE":
SYNOLOGY_GLOBALS["MODE"] = Mode.DIRECTORY_DOWNLOAD
elif choice == "BROWSE MODE":
SYNOLOGY_GLOBALS["MODE"] = Mode.BROWSE
return
def validate(self, document):
ok = regex.match("^[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)$",
document.text)
if not ok:
raise PyInquirer.ValidationError(
message="Please Enter A Valid Number",
cursor_position=len(document.text))
def main_menu():
main_menu_promt = {
'type': 'list',
'name': 'main_choice',
'message': 'Choose an option\n',
'choices': [v for k, v in mm_choices.items()]
}
while (True):
print('\n')
mm_answers = pyq.prompt(main_menu_promt)
if mm_answers['main_choice'] is mm_choices['back']:
break
elif mm_answers['main_choice'] is mm_choices['ss_script']:
ss_menu()
elif mm_answers['main_choice'] is mm_choices['en_dis_auto']:
autostart_menu()
elif mm_answers['main_choice'] is mm_choices['show_log']:
read_main_log()
elif mm_answers['main_choice'] is mm_choices['config']:
cli.config_menu()
def prompt_commun_transfer_params(self):
"""Prompt the common parameters necessary for all transfers.
Returns:
List of transfer parameters : from_chain, to_chain, from_assets,
to_assets, asset_name, receiver
"""
from_chain, to_chain = self.prompt_transfer_networks()
from_assets, to_assets = self.get_registered_assets(
from_chain, to_chain)
questions = [{
'type': 'list',
'name': 'asset_name',
'message': 'Name of asset to transfer',
'choices': from_assets + to_assets
}, {
'type': 'input',
'name': 'receiver',
'message': 'Receiver of assets on other side of bridge'
}]
answers = inquirer.prompt(questions, style=aergo_style)
receiver = answers['receiver']
asset_name = answers['asset_name']
return from_chain, to_chain, from_assets, to_assets, asset_name, \
receiver
def query_address() -> typing.Optional[typing.Dict[str, str]]:
"""Query an address from the user."""
answers = PyInquirer.prompt([
{
"type": "input",
"name": "name",
"message": "Enter name:"
},
{
"type": "input",
"name": "street1",
"message": "Enter street1:"
},
{
"type": "input",
"name": "street2",
"message": "Enter street2:"
},
{
"type": "input",
"name": "city",
"message": "Enter city:"
},
{
"type": "input",
"name": "state",
"message": "Enter state:"
},
{
"type": "input",
"name": "zipcode",
"message": "Enter zipcode:"
},
])
return answers or None