class TestDynamicTexts(BaseTestCase): def setUp(self): super(TestDynamicTexts, self).setUp() self.menu = ConsoleMenu(menu_title, menu_subtitle) self.first_call = True def test_(self): global title_text, subtitle_text, item_title_text menu_item = MenuItem(item_title, self.menu) # Test dynamic change of main menu title self.assertEqual(self.menu.get_title(), "title") title_text = "newtitle" self.assertEqual(self.menu.get_title(), "newtitle") # Test dynamic change of main menu subtitle self.assertEqual(self.menu.get_subtitle(), "subtitle") subtitle_text = "newsubtitle" self.assertEqual(self.menu.get_subtitle(), "newsubtitle") # Test dynamic menu item text self.assertEqual(menu_item.get_text(), "itemtext") item_title_text = "newtext" self.assertEqual(menu_item.get_text(), "newtext") # Test dynamic change of submenu item on each invocation submenu_item = SubmenuItem("a_sub", my_submenu_function) self.assertEqual(submenu_item.get_submenu().get_title(), "version1") self.assertEqual(submenu_item.get_submenu().get_title(), "version2")
def my_submenu_function(): global count if count == 0: count = count + 1 return ConsoleMenu("version1") else: return ConsoleMenu("version2")
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 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 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 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 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 test_init(self): menu1 = ConsoleMenu() menu2 = ConsoleMenu("menu2", "test_init", True) menu3 = ConsoleMenu(title="menu3", subtitle="test_init", show_exit_option=False) self.assertIsNone(menu1.title) self.assertEqual(menu2.title, "menu2") self.assertEqual(menu3.title, "menu3") self.assertIsNone(menu1.subtitle) self.assertEqual(menu2.subtitle, "test_init") self.assertEqual(menu3.subtitle, "test_init") self.assertTrue(menu1.show_exit_option) self.assertTrue(menu2.show_exit_option) self.assertFalse(menu3.show_exit_option)
def _chooseFile(self): """_chooseFile internal function Presents the user with a list of flashcard files in the current directory and asks them to select one of them. It then loads that file into a FlashcardSet and sets that internal variable. """ # Find all the flashcard files in the current directory validfilepattern = re.compile(setnameToFilename('(.*)')) allfiles = os.listdir() validfiles = [] for f in allfiles: match = validfilepattern.match(f) if match: validfiles.append(match.group(1)) filechoices = dict(enumerate(validfiles, 1)) # Ask the user which file to load, providing an option for adding a new file choice = ConsoleMenu.static_quickChoice( filechoices, { 'manual': True, 'manual_value': 'Create new file', 'manual_prompt': 'New file name: ' }) setname = choice[1] filename = setnameToFilename(setname) # Now unpickle the file, or initialize a default flashcard set if setname not in validfiles: self._set = FlashcardSet(setname) else: with open(filename, 'rb') as pickledfile: self._set = pickle.load(pickledfile)
def _chooseAnswer(self): """_chooseAnswer internal function Helper function to clean up run function. Lets user choose answer to change, rearrange answers, or add new answer. """ choices = dict(enumerate(self._card._valid_answers, 1)) choices['c'] = 'Change correct answer' choices['d'] = 'Delete an answer' options = { 'manual': True, 'manual_key': 'a', 'manual_value': 'Add new answer', 'manual_prompt': 'Enter new answer: ', 'abstain': True, 'abstain_key': 'q', 'abstain_value': 'Return to edit card menu', 'intro_text': 'Choose one of the answers, or change the correct answer' } choice = ConsoleMenu.static_quickChoice(choices, options) # If the user chooses to return to the edit card menu, nothing needs be done if choice == None: pass # If the user wants to add a new answer, just add it to the list elif choice[0] == 'a': self._card._valid_answers.append(choice[1]) # If the user wants to change the correct answer, convert to int and rearrange list elif choice[0] == 'c': inputtext = input('Enter key for correct answer (integer between 1 and ' \ +str(len(self._card._valid_answers))+'): ') # By default, do nothing (if the user entered an invalid value, screw 'em) newcorrect = None try: newcorrect = int(inputtext) - 1 except: pass # Move the new index to the front of the list, if it's a valid index if newcorrect != None and newcorrect >= 0 \ and newcorrect < len(self._card._valid_answers): self._card._valid_answers.insert( 0, self._card._valid_answers.pop(newcorrect)) # If the user wants to delete an answer, remove it from the list elif choice[0] == 'd': inputtext = input('Enter key for the answer to delete: ') deleteindex = None try: deleteindex = int(inputtext) - 1 except: pass # Delete the item, if it's a valid index if deleteindex != None and deleteindex >= 0 \ and deleteindex < len(self._card._valid_answers): del self._card._valid_answers[deleteindex] # If the user picked one of the answers, allow them to edit it else: answerindex = int(choice[0]) - 1 self._changeAnswer(answerindex)
class TestConsoleMenu(unittest.TestCase): def setUp(self): self.optionOutRangeNumber = 123 self.optionInRangeNumber = 3 self.optionChar = 'x' self.inputExpected = "5" self.myMenu = ConsoleMenu('../Configuration.xml') def testValidateUserInputWithOptionInRange(self): numberOptions = 4 self.assertTrue(self.myMenu.validateUserInput(self.optionInRangeNumber, numberOptions)) def testValidateUserInputWithOptionNotInRange(self): numberOptions = 4 self.assertFalse(self.myMenu.validateUserInput(self.optionOutRangeNumber, numberOptions)) def testValidateUserInputWithOptionAsChar(self): numberOptions = 4 self.assertFalse(self.myMenu.validateUserInput(self.optionChar, numberOptions))
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 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 __init__(self, modes): self.menu = ConsoleMenu("Scene Relighting Control") self.refresh_item = FunctionItem("Refresh frame info", lambda: self.force_main_menu_refresh) self.menu.append_item(self.refresh_item) # Camera controls: exposure and depth range. self.camera_menu = ConsoleMenu("Camera Control") self.camera_menu_item = SubmenuItem("Change camera settings", self.camera_menu, menu=self.menu) self.set_camera_exposure = FunctionItem("Set exposure", self.update_exposure) self.camera_menu.append_item(self.set_camera_exposure) self.exposure = 250 self.depth_range = [1.0, 1.25] self.set_min_depth_item = FunctionItem( "Set min depth [%f]" % self.depth_range[0], self.set_min_depth) self.set_max_depth_item = FunctionItem( "Set max depth [%f]" % self.depth_range[1], self.set_max_depth) self.camera_menu.append_item(self.set_min_depth_item) self.camera_menu.append_item(self.set_max_depth_item) self.menu.append_item(self.camera_menu_item) # Mode selection self.modes = modes self.mode_name = self.modes[0] self.mode_menu = ConsoleMenu("Demo Modes", "Active mode: %s" % self.mode_name) self.mode_menu_item = SubmenuItem("Change demo mode", self.mode_menu, menu=self.menu) self.mode_items = [] for key in self.modes: new_mode_item = FunctionItem("Set mode [%s]" % key, partial(self.set_mode, key)) self.mode_items.append(new_mode_item) self.mode_menu.append_item(new_mode_item) self.menu.append_item(self.mode_menu_item) # Enable/display meshcat vis self.meshcat_vis_active = True self.toggle_meshcat_vis_item = FunctionItem("Disable meshcat vis", self.toggle_meshcat_vis) self.menu.append_item(self.toggle_meshcat_vis_item) # Enable/disable face detection self.face_detection_active = True self.toggle_detector_item = FunctionItem("Disable face detector", self.toggle_face_detector) self.menu.append_item(self.toggle_detector_item) # Adjust image save rate self.image_save_rate = 0 self.set_image_save_rate_item = FunctionItem( "Set frame divider for image saving [curr %d]" % self.image_save_rate, self.set_image_save_rate) self.menu.append_item(self.set_image_save_rate_item) self.menu.start()
def test_init(self): root_menu = ConsoleMenu("root_menu", "test_init") submenu1 = ConsoleMenu("submenu1", "test_init") submenu2 = ConsoleMenu("submenu2", "test_init") submenu3 = ConsoleMenu("submenu2", "test_init") menu_item_1 = SubmenuItem("menu_item_1", submenu1) menu_item_2 = SubmenuItem("menu_item_2", submenu2, root_menu, True) menu_item_3 = SubmenuItem(text="menu_item_3", submenu=submenu3, menu=root_menu, should_exit=False) self.assertEqual(menu_item_1.text, "menu_item_1") self.assertEqual(menu_item_2.text, "menu_item_2") self.assertEqual(menu_item_3.text, "menu_item_3") self.assertIsNone(menu_item_1.menu) self.assertEqual(menu_item_2.menu, root_menu) self.assertEqual(menu_item_3.menu, root_menu) self.assertFalse(menu_item_1.should_exit) self.assertTrue(menu_item_2.should_exit) self.assertFalse(menu_item_3.should_exit) self.assertEqual(menu_item_1.submenu, submenu1) self.assertEqual(menu_item_2.submenu, submenu2) self.assertEqual(menu_item_3.submenu, submenu3) self.assertIsNone(menu_item_1.submenu.parent) self.assertEqual(menu_item_2.submenu.parent, root_menu) self.assertEqual(menu_item_3.submenu.parent, root_menu)
def test_init(self): menu = ConsoleMenu("menu", "test_init") exit_item_1 = ExitItem("exit_item_1") exit_item_2 = ExitItem("exit_item_2", menu) exit_item_3 = ExitItem(text="exit_item_3", menu=menu) self.assertEqual(exit_item_1.text, "exit_item_1") self.assertEqual(exit_item_2.text, "exit_item_2") self.assertEqual(exit_item_3.text, "exit_item_3") self.assertEqual(exit_item_1.menu, None) self.assertEqual(exit_item_2.menu, menu) self.assertEqual(exit_item_3.menu, menu) self.assertTrue(exit_item_1.should_exit) self.assertTrue(exit_item_2.should_exit) self.assertTrue(exit_item_3.should_exit)
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 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 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 setUp(self): self.menu = ConsoleMenu("self.menu", "TestMenuItem") self.small_list = [ MenuItem("menu_item_1", self.menu), MenuItem("menu_item_2", self.menu, True), MenuItem(text="menu_item_3", menu=self.menu, should_exit=False) ] self.large_list = [ MenuItem("menu_item_1", self.menu), MenuItem("menu_item_2", self.menu, True), MenuItem("menu_item_3", self.menu, True), MenuItem("menu_item_4", self.menu, True), MenuItem("menu_item_5", self.menu, True), MenuItem("menu_item_6", self.menu, True), MenuItem("menu_item_7", self.menu, True), MenuItem("menu_item_8", self.menu, True), MenuItem("menu_item_9", self.menu, True), MenuItem("menu_item_10", self.menu, True), MenuItem("menu_item_11", self.menu, True), MenuItem(text="menu_item_12", menu=self.menu, should_exit=False) ]
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 run(self): """run function Displays a menu of a few possible options and allows the user to pick among them. Includes importing a CSV, manually editing cards, running the cards, and displaying stats. """ choices = { 'i': "Import Cards", 'e': "Export Cards", 'c': "Edit cards", 'o': "Edit options", 'r': "Run cards", 's': "Show stats" } options = { 'abstain': True, 'abstain_key': 'q', 'abstain_value': "Quit" } choice = ConsoleMenu.static_quickChoice(choices, options) # If the user wants to exit, set the next to None and do nothing else if choice == None: self.next = None else: # Call the appropriate state, based on the user's choice if choice[0] == 'i': self.next = FCStateImportCSV(self._set, self) elif choice[0] == 'e': self._exportCSV() elif choice[0] == 'c': self.next = FCStateEditCardsMain(self._set, self) elif choice[0] == 'o': print('Go to ' + choice[1]) elif choice[0] == 'r': self.next = FCStateRunCardsMenu(self._set, self) elif choice[0] == 's': self._showStats()
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 run(self): """run function Displays a menu of a few possible attributes to edit. Question, answers, confirm override, and answer type. """ choices = { 'u': 'Change question text (current: "' + self._card._question + '")', 'a': 'Change answers (current: "' + str(self._card._valid_answers) + '")', 't': 'Change answer type (current: "' + self._card._answer_type + '")', 'c': 'Change confirm override (current: "' + str(self._card._override_confirms) + '")' } options = { 'abstain': True, 'abstain_key': 'q', 'abstain_value': "Return to edit cards main menu", } choice = ConsoleMenu.static_quickChoice(choices, options) # If the user wants to return to main menu, set the next and do nothing else if choice == None: self.next = self._editcardsmain else: # Run a helper function based on the user choice if choice[0] == 'u': self._changeQuestionText() elif choice[0] == 'a': self._chooseAnswer() elif choice[0] == 't': self._changeAnswerType() elif choice[0] == 'c': self._changeOverrideConfirm()
def _changeOverrideConfirm(self): """_changeOverrideConfirm internal function Helper function to clean up run function. Lets user change override confirm. """ choices = {'1': True, '2': False} options = { 'abstain': True, 'abstain_key': 'q', 'abstain_value': 'Return to edit card menu', 'intro_text': 'Choose an override confirm setting (current: ' + str(self._card._override_confirms) + ')' } choice = ConsoleMenu.static_quickChoice(choices, options) # If the user wants to quit, nothing needs be done if choice == None: pass # Otherwise, set the new override confirm else: self._card._override_confirms = choice[1]
def _changeAnswerType(self): """_changeAnswerType internal function Helper function to clean up run function. Lets user change answer type. """ choices = dict(enumerate(FlashcardSet.ANSWER_TYPES, 1)) options = { 'abstain': True, 'abstain_key': 'q', 'abstain_value': 'Return to edit card menu', 'intro_text': 'Choose an answer type (current: ' + self._card._answer_type + ')' } choice = ConsoleMenu.static_quickChoice(choices, options) # If the user wants to quit, nothing needs be done if choice == None: pass # Otherwise, set the new answer type else: self._card._answer_type = FlashcardSet.ANSWER_TYPES[int(choice[0]) - 1]
def _askMultipleChoice(self, question, answers): """_askMultipleChoice internal function Simply presents the user with the question and a choice menu for an answer. Returns the answer the user chose. """ print("Question: " + question) # If the question is boolean, generate a choices dict of just True and False if len(answers) == 1 and answers[0] in ('True', 'False'): choices = {'1': 'True', '2': 'False'} # Otherwise, the answers are just what was passed to us # Make sure to randomize the order else: choices = dict( enumerate(sorted(answers, key=lambda k: random.random()), 1)) options = { 'abstain': True, 'abstain_key': 'q', 'abstain_value': 'Return to menu' } choice = ConsoleMenu.static_quickChoice(choices, options) if choice == None: return 'q' return choice[1]
def setUp(self): super(TestSelectionItem, self).setUp() self.menu = ConsoleMenu("self.menu", "TestSelectionItem")
def test_currently_active_menu(self): menu1 = ConsoleMenu("menu1", "test_currently_active_menu_1") menu2 = ConsoleMenu("menu2", "test_currently_active_menu_2") menu3 = ConsoleMenu("menu3", "test_currently_active_menu_3") self.assertIsNone(ConsoleMenu.currently_active_menu) menu1.start() menu1.wait_for_start(10) self.assertIs(ConsoleMenu.currently_active_menu, menu1) menu2.start() menu2.wait_for_start(10) self.assertIs(ConsoleMenu.currently_active_menu, menu2) menu3.start() menu3.wait_for_start(10) self.assertIs(ConsoleMenu.currently_active_menu, menu3) menu3.join(timeout=5) menu2.join(timeout=5) menu1.join(timeout=5)
def setUp(self): self.optionOutRangeNumber = 123 self.optionInRangeNumber = 3 self.optionChar = 'x' self.inputExpected = "5" self.myMenu = ConsoleMenu('../Configuration.xml')
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())
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 miMenu = ConsoleMenu('Configuration.xml') miMenu.mainOptionsMenu() miMenu.displayOptionsSelected() miMenu.mainOptionsMenu()