def show_first_menu():
# Record which models are in the models folder
models_list = [
f for f in listdir(models_path)
if isfile(join(models_path, f)) and f[-4:] == ".dat"
]
first_menu = ConsoleMenu("Main menu")
submenu = SelectionMenu(models_list, "Load Model")
submenu_item = SubmenuItem("Load a model",
submenu,
menu=first_menu,
should_exit=True)
first_menu.append_item(submenu_item)
first_menu.start()
first_menu.join()
if submenu.selected_option >= len(models_list):
show_first_menu()
return
elif submenu.selected_option == -1:
return
selected_model = models_list[submenu.selected_option]
net, jtree = util.load_model(models_path + selected_model)
if net is not None and jtree is not None:
jtree.initialize_tables(net)
print("Model loaded succesfully")
show_loaded_model_menu(selected_model, net, jtree)
else:
show_first_menu()
def select_scan():
global lightsheetPackages, lightsheetScanPaths, displayNames
scanIndex = SelectionMenu.get_selection(displayNames)
if scanIndex >= len(displayNames):
return None
scanName = displayNames[scanIndex]
scan = lightsheetPackages[scanIndex]
attribs = scan.get_filled_attr_dict()
# TODO: Open the scan and spawn the GUI showing the metadata and thumbnail
analysisList = ['3D Density Map', 'Stroke Volume', 'Vessel Diameter']
scanMenu = ConsoleMenu(scanName, exit_option_text="Close Scan")
viewAttribsItem = FunctionItem("View Metadata", show_scan_metadata,
[attribs])
viewMaxProjItem = FunctionItem("View Max-Proj", show_scan_maxproj,
[attribs['maxProjPath'], attribs['name']])
#selectAnalysisPackageItem = FunctionItem("View Analysis", select_existing_analysis, [analysisList])
#createNewAnalysisPackageItem = FunctionItem("Import Analysis", perform_new_analysis, [analysisList])
downloadScanItem = FunctionItem("Download Copy", download_scan,
[scan.get_uniqueID()])
scanMenu.append_item(viewAttribsItem)
scanMenu.append_item(viewMaxProjItem)
#scanMenu.append_item(selectAnalysisPackageItem)
#scanMenu.append_item(createNewAnalysisPackageItem)
scanMenu.append_item(downloadScanItem)
scanMenu.show()
def _create_menu(desc, epilogue_text, menu_items):
console_menu = ConsoleMenu(
"Getting and Setting Channel Values API Demo",
desc,
epilogue_text=epilogue_text)
for name, fn, args, opts in menu_items:
menu_item = FunctionItem(name, fn, args, **opts)
console_menu.append_item(menu_item)
return console_menu
def _create_menu(desc, epilogue_text, menu_items):
console_menu = ConsoleMenu("Test Session API Demo",
desc,
epilogue_text=epilogue_text)
console_menu.append_item(refresh_test_session_state)
for name, fn, args, opts in menu_items:
menu_item = FunctionItem(name, fn, args, **opts)
console_menu.append_item(menu_item)
return console_menu
def test_remove_menu_item(self):
menu = ConsoleMenu("menu1", "test_currently_active_menu_1")
item1 = MenuItem(text='itemText', menu=menu)
item2 = MenuItem(text='itemText2', menu=menu)
menu.append_item(item1)
menu.append_item(item2)
self.assertIn(item1, menu.items)
self.assertIn(item2, menu.items)
menu.remove_item(item1)
self.assertNotIn(item1, menu.items)
self.assertIn(item2, menu.items)
def vm_menu():
menu = ConsoleMenu("Virtual Machine", "Created with Python")
submenu = ConsoleMenu("About Us")
submenu.prologue_text = "This is Virtual Machine. Created by Vilnius Gediminas " \
"Technical University PRIfs 18/6 student - Rimvydas Kanapka." \
" This program is created for Architecture of Computers and Computer Networks."
menu.append_item(FunctionItem("Start VM", main)) # First menu item
menu.append_item(SubmenuItem("About Us", submenu,
menu=menu)) # Second menu item
menu.show()
def tm_menu():
menu = ConsoleMenu("Turing Machine Simulator", "Created with Python")
submenu = ConsoleMenu("About Us")
submenu.prologue_text = "This is Turing Machine Simulator created by Vilnius Gediminas Technical University " \
"PRIfs 18/6 student - Rimvydas Kanapka." \
" This program is created for Architecture of Computers and Computer Networks."
menu.append_item(FunctionItem("RUN Turing Machine",
action)) # First menu item
menu.append_item(SubmenuItem("About Us", submenu,
menu=menu)) # Second menu item
menu.show()
def process_data(name, data, page, nested=None):
if isinstance(data, Exception):
Screen().input(f"DError: {data}")
return
subtitle = "".join(f"{i} " for i in columns[name])
arr = [f" Page {page - 1}", f" Page {page + 1}"]
for en in data:
arr.append(" ".join(map(str, en)))
sel = SelectionMenu.get_selection(arr, subtitle)
if sel in range(2, len(arr)):
subtitle = ""
for i in range(len(columns[name])):
subtitle += f"{columns[name][i]}: {data[sel - 2][i]}; "
menu = ConsoleMenu("Item actions", subtitle)
if name == "Seller" and nested == None:
menu.append_item(
FunctionItem("Find products", find_products,
[data[sel - 2][0], 1]))
elif name == "Product" and nested == None:
menu.append_item(
FunctionItem("Find sellers", find_sellers,
[data[sel - 2][0], 1]))
menu.append_item(
FunctionItem("Edit", update,
[name, columns[name][0], data[sel - 2][0]]))
menu.append_item(
FunctionItem("Delete", delete,
[name, columns[name][0], data[sel - 2][0]]))
menu.show()
elif sel < 2:
return sel + 1
def manually_mod_settings(set_dict):
#quick and dirsty workaround - older settings files don't include rand, d.
if 'RANDOM_DISABLE_CHANCE' not in set_dict.keys():
set_dict['RANDOM_DISABLE_CHANCE'] = RANDOM_DISABLE_CHANCE
menu = ConsoleMenu("Tune parameters", "[original value] / <new value>")
menu_items = []
for idx, (key, val) in enumerate(set_dict.items()):
desc = f"{key}[{val}]"
prompt = f"{key}[{val}] : "
def prompt_func(text, set_key):
value = input(text)
if set_key in ['PID_ENABLED', 'COLLISION']:
set_dict[set_key] = True if value.startswith(
('T', 't')) else False
elif set_key == 'PID_PARAMS':
set_dict[set_key] = [
float(x) for x in value.replace(' ', ',').split(',')
]
elif isInt(float(value)):
set_dict[set_key] = int(value)
else:
set_dict[set_key] = float(value)
return value
if key in ['PID_ENABLED', 'COLLISION']:
prompt = f"{key}[{val}](F/T) : "
if key == 'PID_PARAMS':
prompt = "PID <P I D>: "
menu_items.append(FunctionItemMod(desc, prompt_func,
[prompt, key]))
else:
menu_items.append(FunctionItemMod(desc, prompt_func,
[prompt, key]))
menu.append_item(menu_items[idx])
def print_sett():
for key, item in set_dict.items():
print(f"{key} : {item}")
input('\nPress any key to return!')
menu.append_item(FunctionItem("PRINT CURRENT SETTINGS", print_sett))
menu.show()
return set_dict
def main():
if len(argv) < 2:
menu = ConsoleMenu("Mechanism Types",
"Choose which mechanism you are characterizing")
for mechanism, tools in tool_dict.items():
tool_menu = ConsoleMenu(f"Characterization Tools: {mechanism}")
for tool, function in tools.items():
tool_menu.append_item(
FunctionItem(tool, function, menu=tool_menu))
menu.append_item(SubmenuItem(mechanism, tool_menu, menu))
menu.show()
else:
parser = argparse.ArgumentParser(
description="FRC characterization tools CLI")
parser.add_argument(
"mech_type",
choices=list(tool_dict.keys()),
help="Mechanism type being characterized",
)
parser.add_argument(
"tool_type",
choices=list(list(tool_dict.values())[0].keys()),
help=
"Create new project, start data recorder/logger, or start data analyzer",
)
parser.add_argument(
"project_directory",
help=
"Location for the project directory (if creating a new project)",
nargs="?",
default=None,
)
argcomplete.autocomplete(parser)
args = parser.parse_args()
tool_dict[args.mech_type][args.tool_type](
directory=args.project_directory)
def test_action(self):
root_menu = ConsoleMenu("root_menu", "test_action")
submenu1 = ConsoleMenu("submenu1", "test_action")
submenu2 = ConsoleMenu("submenu2", "test_action")
submenu_item_1 = SubmenuItem("submenu_item_1", submenu1, menu=root_menu)
submenu_item_2 = SubmenuItem("submenu_item_2", submenu2, menu=root_menu)
root_menu.append_item(submenu_item_1)
root_menu.append_item(submenu_item_2)
root_menu.start()
root_menu.wait_for_start(timeout=10)
self.assertIs(ConsoleMenu.currently_active_menu, root_menu)
submenu_item_1.action()
submenu1.wait_for_start(timeout=10)
self.assertIs(ConsoleMenu.currently_active_menu, submenu1)
ConsoleMenu.currently_active_menu.exit()
submenu1.join(timeout=10)
self.assertIs(ConsoleMenu.currently_active_menu, root_menu)
submenu_item_2.action()
submenu2.wait_for_start(timeout=10)
self.assertIs(ConsoleMenu.currently_active_menu, submenu2)
def manage_devices(devices):
"""
Enable/disable a device
:param devices: A device object
"""
prologue_text = "\n".join([
"{} ({})".format(d.name, "Enabled" if d.is_enabled else "Disabled")
for d in devices
])
menu = ConsoleMenu(title="Emulation > Devices",
prologue_text=prologue_text)
menu.append_item(
FunctionItem("Enable",
api.toggle_devices,
args=[devices, True],
should_exit=True))
menu.append_item(
FunctionItem("Disable",
api.toggle_devices,
args=[devices, False],
should_exit=True))
menu.show()
def main():
#List containing the choices of the user
desired_properties: List[DesiredProperty] = []
#Load ontology
amsterdam_neighbourhoods = pd.read_csv("data/amsterdam.csv")
# Create the menu
menu = ConsoleMenu("AreA", "An advisor on Amsterdam's residential areas")
# Menu Items
desired_prop_item = FunctionItem("Add desired property",
desired_prorerty_submenu,
[desired_properties])
view_sugg_item = FunctionItem(
"Get suggestions", view_suggestions_func,
[amsterdam_neighbourhoods, desired_properties])
# Once we're done creating them, we just add the items to the menu
menu.append_item(desired_prop_item)
menu.append_item(view_sugg_item)
# start menu
menu.show()
def menu():
"""
Make use of an interactive menu.
"""
interactive_menu = ConsoleMenu("Welcome to qr-rocket menu",
"Select an option")
interactive_menu.append_item(
CommandItem("Create a new PDF file", "rocketqr create"))
interactive_menu.append_item(
CommandItem("Delete all auto generated files", "rocketqr delete"))
interactive_menu.append_item(
CommandItem("Go to templates menu", "rocketqr templates menu"))
interactive_menu.show()
def utf_menu():
menu = ConsoleMenu("Decimal number convertor & File Decoder",
"Created with Python")
submenu = ConsoleMenu("About Us")
submenu.prologue_text = "This is Decimal number convertor which takes a decimal number as a input and shows " \
"number's Unicode, UTF-8 and single character. Created by Vilnius Gediminas " \
"Technical University PRIfs 18/6 student - Rimvydas Kanapka." \
" This program is created for Architecture of Computers and Computer Networks."
menu.append_item(
FunctionItem("GET Unicode, UTF-8 & Char of a Decimal Number",
get_info)) # First menu item
menu.append_item(FunctionItem("Decode File", decode)) # Second menu item
menu.append_item(SubmenuItem("About Us", submenu,
menu=menu)) # Third menu item
menu.show()
def output_console_menu():
start_directory = os.getcwd()
directory_content = get_directory_content(start_directory, False)
file_selection_menu = ConsoleMenu("Select file from:", start_directory)
for current_dir_item in directory_content:
current_dir_item_path = start_directory + os.path.sep + current_dir_item
if os.path.isfile(current_dir_item_path):
file_selection_menu.append_item(FunctionItem(current_dir_item,
get_statistic,
[current_dir_item_path, tasks_list]))
elif os.path.isdir(current_dir_item_path):
current_sub_menu = ConsoleMenu("Select file from:", current_dir_item_path)
for current_subdir_item in get_directory_content(current_dir_item_path, True):
current_sub_menu.append_item(FunctionItem(current_subdir_item,
get_statistic,
[
current_dir_item_path + os.path.sep + current_subdir_item, tasks_list]))
file_selection_menu.append_item(SubmenuItem(current_dir_item + os.path.sep, current_sub_menu))
file_selection_menu.show()
def init_menu(self):
titulo = "Menú principal"
subtitulo = "Programa para cifrar ficheros con AES 256 GCM"
prologue = "Para poder encriptar ficheros tiene que estar situados en la carpeta files."\
" Los ficheros *.encrypted y *.decrypted se situarán en la misma carpeta."
if not os.path.exists("./my_keystore.jks"):
prologue += " PARA HACER USO DE LAS FUNCIONES DE ENCRIPTADO Y DESENCRIPTADO, DEBE CREAR UN ALMACÉN DE CLAVES Y UNA CLAVE (3)."
menu = ConsoleMenu(titulo, subtitulo, prologue_text=prologue)
cifrado = FunctionItem("Cifrado del fichero", self.encrypt)
descifrado = FunctionItem("Descifrado del fichero", self.decrypt)
generado_claves = FunctionItem("Generar nueva clave privada",
self.generate_key)
menu.append_item(cifrado)
menu.append_item(descifrado)
menu.append_item(generado_claves)
menu.show()
def main():
init()
# Define main menu
menu = ConsoleMenu(
title="Music Library Manager",
subtitle="Main Menu",
)
# Define add menu
addMenu = ConsoleMenu(
title="Music Library Manager",
subtitle="Where would you like to add a new track?",
exit_option_text="Back"
)
# Define main menu options
opt_display = FunctionItem(
"Display Music Library", wait_func, [displayLibrary])
opt_add = SubmenuItem("Add a new track", addMenu)
# Define add menu options
opt_add_start = FunctionItem(
"At the beginning of the list", wait_func, [addTune])
# Add options to the main menu
menu.append_item(opt_add)
menu.append_item(opt_display)
# Add options to the add menu
addMenu.append_item(opt_add_start)
# Display the menu and wait for user input
menu.show()
# Print when user runs the 'Exit' option
print("Exiting...")
discovering_website = Project()
load_or_new = input('Do you want to load a project from disk? (y/n) ')
if load_or_new == 'y':
path = input('Path: ')
discovering_website.load(path)
else:
name = input('Name: ')
description = input('Description: ')
discovering_website = Project(name, description)
interface = ConsoleInterfaceWrapper(discovering_website)
m_main = ConsoleMenu('WebSiDis console interface')
m_notes = ConsoleMenu('Notes')
m_notes.append_item(FunctionItem('Add new note', interface.wrapAddNote))
m_notes.append_item(
FunctionItem('Remove existed note', interface.wrapRemNote))
m_notes.append_item(
FunctionItem('Show notes', interface.wrapShow, ['notes']))
m_related = ConsoleMenu('Sites')
m_related.append_item(
FunctionItem('Add new related site', interface.wrapAddRelated))
m_related.append_item(
FunctionItem('Remove existed related site', interface.wrapRemRelated))
m_related.append_item(
FunctionItem('Show related sites', interface.wrapShow, ['related']))
m_structure = ConsoleMenu('Structure')
m_structure.append_item(FunctionItem('Add new page',
stream = f.read()
temp = yaml.load(stream)
config = napalm_yang.base.Root()
config.add_model(napalm_yang.models.openconfig_interfaces())
config.load_dict(temp)
def show_data(args):
if "yaml" in args:
print(stream)
elif "dict" in args:
pretty_print(temp)
elif "yang" in args:
pretty_print(napalm_yang.utils.model_to_dict(config))
elif "gen" in args:
pretty_print(config.get(filter=True))
elif "junos" in args:
print(config.translate_config(profile=["junos"]))
elif "ios" in args:
print(config.translate_config(profile=["ios"]))
else:
return
input("Press Enter")
menu = ConsoleMenu("Menu")
menu_dict = {"yaml":"YAML data model", "dict": "python dictionary", "yang": "YANG model. Warning: long output.", "gen": "generated YANG data", "junos":"JunOS config", "ios":"IOS config"}
for key, value in menu_dict.items():
function_item = FunctionItem("View the " + value, show_data, [key])
menu.append_item(function_item)
menu.show()
task = Thread(target=main, args=args)
task_menu = FunctionItem(name,
terminate_task, [task, name],
should_exit=True)
task_menu.args.append(task_menu)
tasks_menu.append_item(task_menu)
task.start()
print('Started successfully.')
input()
Client.login()
gen_menu = ConsoleMenu('Send messages and files')
gen_menu.append_item(FunctionItem('Send message', Client.send_message))
gen_menu.append_item(FunctionItem('Send file', Client.send_file))
gen_menu.append_item(FunctionItem('Bulk send', Client.bulk_send))
gen_menu.append_item(FunctionItem('User info', Client.user_info))
gen_menu.append_item(FunctionItem('Server list', Client.get_servers))
gen_menu.append_item(FunctionItem('Member list', Client.create_list))
gen_menu.append_item(FunctionItem('Download avatar', Client.download_avatar))
exploit_menu = ConsoleMenu('Exploits and misc features')
exploit_menu.append_item(
FunctionItem('Infinite typing', create_task,
['Infinite typing', Exploits.typing, 'Channel ID']))
exploit_menu.append_item(
FunctionItem('Status changer', create_task,
['Status changer', Exploits.status_changer]))
exploit_menu.append_item(FunctionItem('Friend finder', Exploits.friend_list))
def main():
"""
Run the intial setup script, check for an input file and show the main menu
"""
init_script()
read_info_file()
# Define Menu
menu = ConsoleMenu(
title="AWS EC2 and S3 Webserver Configuration Script",
subtitle="Developer Operations Assignment 1 - Dylan Gore",
)
# Define menu options and what they do
opt_full_run = FunctionItem("Run automatic configuration", wait_func,
[full_run])
opt_user_input = FunctionItem("Input custom settings", wait_func,
[accept_user_input])
opt_active = FunctionItem("List running instances/active buckets",
wait_func, [list_active])
opt_monitoring = FunctionItem("Display monitoring info", wait_func,
[display_monitor])
# opt_website = FunctionItem("Check if web server is running", wait_func, [check_website])
# opt_iam = FunctionItem("Create IAM role & policy", wait_func, [check_for_iam_role, iam, sts_client])
opt_configure_aws = CommandItem("Configure AWS credentials and Settigns",
"aws configure")
opt_load_config_file = FunctionItem("Load configuration file", wait_func,
[read_info_file])
opt_cleanup = FunctionItem("Cleanup AWS", wait_func, [cleanup])
opt_clear_logs = FunctionItem("Clear logs", wait_func, [clear_logs])
# Add options to menu
menu.append_item(opt_full_run)
menu.append_item(opt_user_input)
menu.append_item(opt_active)
menu.append_item(opt_monitoring)
# menu.append_item(opt_website)
# menu.append_item(opt_iam)
menu.append_item(opt_configure_aws)
menu.append_item(opt_load_config_file)
menu.append_item(opt_cleanup)
menu.append_item(opt_clear_logs)
# Display the menu and wait for user input
menu.show()
# Print when user runs the 'Exit' option
print("Exiting...")
from consolemenu import ConsoleMenu
from consolemenu.items import FunctionItem, SubmenuItem, CommandItem
menu = ConsoleMenu(title='Menu Title', subtitle='Subtitle')
command_item = CommandItem('Run a console command!', 'touch.txt')
function_item = FunctionItem('call a function', input, ['enter input'])
submenu = ConsoleMenu('a submenu')
submenu_item = SubmenuItem('show a submenu', submenu, menu=menu)
menu.append_item(command_item)
menu.append_item(function_item)
menu.append_item(submenu_item)
# menu.start()
# menu.join()
menu.show()
epilogue_text=lightsheetEpilogue,
exit_option_text="Main Menu")
lightsheetItem = SubmenuItem("Lightsheet Data", lightsheetMenu, mainMenu)
ephysMenu = ConsoleMenu("EPhys Data [Not Implemented]",
exit_option_text="Main Menu")
ephysItem = SubmenuItem("Ephys Data", ephysMenu, mainMenu)
confocalMenu = ConsoleMenu("Confocal Data [Not Implemented]",
exit_option_text="Main Menu")
confocalItem = SubmenuItem("Confocal Data", confocalMenu, mainMenu)
behaviorMenu = ConsoleMenu("Behavior Data [Not Implemented]",
exit_option_text="Main Menu")
behaviorItem = SubmenuItem("Behavior Data", behaviorMenu, mainMenu)
cellCultureMenu = ConsoleMenu("Cell Culture Data [Not Implemented]",
exit_option_text="Main Menu")
cellCultureItem = SubmenuItem("Cell Culture Data", cellCultureMenu, mainMenu)
openScanMenuItem = FunctionItem("Open Scan",
select_scan, [],
menu=lightsheetMenu)
importScanMenuItem = FunctionItem("Import Scan", create_scan, [])
mainMenu.append_item(lightsheetItem)
mainMenu.append_item(ephysItem)
mainMenu.append_item(confocalItem)
mainMenu.append_item(behaviorItem)
mainMenu.append_item(cellCultureItem)
lightsheetMenu.append_item(openScanMenuItem)
lightsheetMenu.append_item(importScanMenuItem)
mainMenu.show()
def show_loaded_model_menu(model, net, jtree):
# Record which models are in the models folder
models_list = [
f for f in listdir(models_path)
if isfile(join(models_path, f)) and str(f)[-4:] == ".dat"
]
menu = ConsoleMenu("Main menu - " + model)
describe_bnet = FunctionItem("Describe Bayesian Net",
function=lambda net: print(str(net)),
args=[net])
describe_jtree = FunctionItem("Describe Junction Tree",
function=lambda jtree: print(str(jtree)),
args=[jtree])
visualize = FunctionItem(
"Visualize Bayesian Net and Junction Tree",
function=lambda path: os.system("visualize.py " + path),
args=[models_path + model])
propagate = FunctionItem(
"Propagate evidence",
function=lambda jtree:
[jtree.sum_propagate(),
print("Evidence propagated")],
args=[jtree])
load_new_model = SelectionMenu(models_list, "Load New Model")
load_new_model_item = SubmenuItem("Load a new model",
load_new_model,
menu=menu,
should_exit=True)
add_evidence = FunctionItem("Add evidence",
function=add_evidence_option,
args=[jtree])
get_probability = FunctionItem("Get probability of a variable",
function=get_probability_option,
args=[jtree])
reset_model = FunctionItem(
"Reset Model",
function=lambda net, jtree:
[jtree.initialize_tables(net),
print("Tables reinitialized")],
args=[net, jtree])
menu.append_item(describe_bnet)
menu.append_item(describe_jtree)
menu.append_item(visualize)
menu.append_item(add_evidence)
menu.append_item(get_probability)
menu.append_item(propagate)
menu.append_item(reset_model)
menu.append_item(load_new_model_item)
menu.start()
menu.join()
if load_new_model.selected_option >= len(models_list):
show_loaded_model_menu(model, net, jtree)
return
elif load_new_model.selected_option == -1:
return
selected_model = models_list[load_new_model.selected_option]
net, jtree = util.load_model(models_path + selected_model)
if net is not None and jtree is not None:
jtree.initialize_tables(net)
print("Model loaded succesfully")
show_loaded_model_menu(selected_model, net, jtree)
else:
show_first_menu()
def templates_menu():
templates_menu = ConsoleMenu("You are in qr-rocket templates menu", "Select an option")
templates_menu.append_item(CommandItem("Show templates", "rocketqr templates show"))
templates_menu.append_item(CommandItem("Create new template", "rocketqr templates create"))
templates_menu.append_item(CommandItem("Go back to main menu", "rocketqr menu"))
templates_menu.show()
def main():
# Create the menu
menu = ConsoleMenu(
"Lena's Bank main menu",
"Welcome to Lena's Bank! Please select from the following menu:")
# A FunctionItem runs a Python function when selected
list_of_all_customers_function = FunctionItem("List of all customers",
bank.list_of_all_customers)
find_customer_function = FunctionItem("Find customer by SSN",
bank.find_customer)
update_customer_info_function = FunctionItem("Update customer info",
bank.update_customer)
remove_customer_function = FunctionItem("Remove customer",
bank.remove_customer)
add_new_customer_function = FunctionItem("Add new customer",
bank.add_new_customer)
get_balance_function = FunctionItem("Get balance", bank.get_balance)
open_new_account_function = FunctionItem("Open New Account",
bank.open_new_account)
close_account_function = FunctionItem("Close account", bank.close_account)
add_new_transaction_function = FunctionItem("Add new transaction",
bank.add_new_transaction)
view_transaction_history_function = FunctionItem(
"View transaction history", bank.transaction_history)
list_of_all_customers_submenu_item = SelectionMenu([])
list_of_all_customers_submenu_item.append_item(
list_of_all_customers_function)
list_of_all_customers_submenu_item.append_item(find_customer_function)
list_of_all_customers_submenu_item.append_item(
update_customer_info_function)
list_of_all_customers_submenu_item.append_item(add_new_customer_function)
list_of_all_customers_submenu_item.append_item(remove_customer_function)
work_with_accounts_selection_menu = SelectionMenu([])
work_with_accounts_selection_menu.append_item(get_balance_function)
work_with_accounts_selection_menu.append_item(open_new_account_function)
work_with_accounts_selection_menu.append_item(close_account_function)
process_transactions_selection_menu = SelectionMenu([])
process_transactions_selection_menu.append_item(
add_new_transaction_function)
process_transactions_selection_menu.append_item(
view_transaction_history_function)
manage_customers_submenu_item = SubmenuItem(
"Manage customers", list_of_all_customers_submenu_item, menu)
accounts_submenu_item = SubmenuItem("Work with accounts",
work_with_accounts_selection_menu,
menu)
process_transactions_submenu_item = SubmenuItem(
"Process Transactions", process_transactions_selection_menu, menu)
menu.append_item(manage_customers_submenu_item)
menu.append_item(accounts_submenu_item)
menu.append_item(process_transactions_submenu_item)
models.create_lenas_bank()
menu.show()
menu = ConsoleMenu("WJSTX Transceiver Control ", "FT8 and FT4")
resp_submenu = ConsoleMenu("Respond with: ", "", exit_option_text="Go back")
#Main menu
cq_item = FunctionItem("Call CQ", call_cq, [False])
continue_cq_item = FunctionItem("Continue Call CQ", call_cq, [True])
retransmit_item = FunctionItem("Retransmit last", transmit, [])
resp_new_item = FunctionItem("Respond to new callsign", resp_new, [])
submenu_item = FunctionItem("Respond to last callsign", resp_last, [])
chfreq_item = FunctionItem("Change TX frequency", change_freq, [])
chft4_item = FunctionItem("Change mode to FT4", change_mode, [])
chft8_item = FunctionItem("Change mode to FT8", change_mode, [])
resp_grid_item = FunctionItem("Respond with grid", respond, ['grid'])
resp_signal_item = FunctionItem("Respond with R + signal strenght", respond,
['signal'])
resp_73_item = FunctionItem("Respond with RR73", respond, ['RR73'])
resp_submenu.append_item(resp_grid_item)
resp_submenu.append_item(resp_signal_item)
resp_submenu.append_item(resp_73_item)
menu.append_item(cq_item)
menu.append_item(continue_cq_item)
menu.append_item(resp_new_item)
menu.append_item(submenu_item)
menu.append_item(retransmit_item)
menu.append_item(chfreq_item)
menu.append_item(chft4_item)
menu.show()
class TestSampleMenu(BaseTestCase):
def setUp(self):
super(TestSampleMenu, self).setUp()
self.menu = ConsoleMenu("self.menu", "TestSampleMenu")
self.item1 = MenuItem("self.item1", self.menu)
self.item2 = MenuItem("self.item2", self.menu)
self.menu.append_item(self.item1)
self.menu.append_item(self.item2)
self.menu.start()
self.menu.wait_for_start(timeout=10)
def tearDown(self):
super(TestSampleMenu, self).tearDown()
self.menu.exit()
self.menu.join(timeout=10)
def test_go_down(self):
self.menu.go_down()
self.assertEqual(self.menu.current_option, 1)
self.assertIs(self.menu.current_item, self.item2)
self.menu.go_down()
self.assertEqual(self.menu.current_option, 2)
self.assertEqual(self.menu.current_item, self.menu.exit_item)
self.menu.go_down()
self.assertEqual(self.menu.current_option, 0)
self.assertIs(self.menu.current_item, self.item1)
def test_go_up(self):
self.menu.go_up()
self.assertEqual(self.menu.current_option, 2)
self.assertIs(self.menu.current_item, self.menu.exit_item)
self.menu.go_up()
self.assertEqual(self.menu.current_option, 1)
self.assertEqual(self.menu.current_item, self.item2)
self.menu.go_up()
self.assertEqual(self.menu.current_option, 0)
self.assertIs(self.menu.current_item, self.item1)
def test_go_to(self):
self.menu.go_to(1)
self.assertEqual(self.menu.current_option, 1)
self.assertEqual(self.menu.current_item, self.item2)
def test_select(self):
self.menu.select()
self.assertEqual(self.menu.selected_option, 0)
self.assertIs(self.menu.selected_item, self.item1)
self.menu.go_down()
self.menu.select()
self.assertEqual(self.menu.selected_option, 1)
self.assertIs(self.menu.selected_item, self.item2)
self.menu.go_down()
self.menu.select()
self.assertEqual(self.menu.selected_option, 2)
self.assertIs(self.menu.selected_item, self.menu.exit_item)
self.menu.join(timeout=10)
self.assertFalse(self.menu.is_alive())
def test_exit(self):
self.assertTrue(self.menu.is_alive())
self.menu.exit()
self.menu.join(timeout=10)
self.assertFalse(self.menu.is_alive())
buildMenu_Fleet = ConsoleMenu('Fleet Menu')
# FUNCTIONS TO EACH MENU
buildMenuMining_FunctionMetal = FunctionItem('Metal Mine', bot.build, args='1')
buildMenuMining_FunctionCrystal = FunctionItem('Crystal Mine',
bot.build,
args='2')
buildMenuMining_FunctionDeuterium = FunctionItem('Deuterium Mine',
bot.build,
args='3')
buildMenuMining_FunctionEnergy = FunctionItem('Enery Plant',
bot.build,
args='4')
# ADD TO EACH MENU
buildMenu_Mining.append_item(buildMenuMining_FunctionMetal)
buildMenu_Mining.append_item(buildMenuMining_FunctionCrystal)
buildMenu_Mining.append_item(buildMenuMining_FunctionDeuterium)
buildMenu_Mining.append_item(buildMenuMining_FunctionEnergy)
# SUBMENUS BUILDING
subMenuMining = SubmenuItem('Mining Menu', buildMenu_Mining, buildMenu)
subMenuStructure = SubmenuItem('Structure Menu', buildMenu)
subMenuDefense = SubmenuItem('Defense Menu', buildMenu)
subMenuFleet = SubmenuItem('Fleet Menu', buildMenu)
buildSubMenu = SubmenuItem('Building Menu', buildMenu)
# SUBMENUS APPENDING TO MAIN MENU
buildMenu.append_item(subMenuMining)
buildMenu.append_item(subMenuStructure)
buildMenu.append_item(subMenuDefense)