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()
