def placeholder(*args, **kwargs):
global root, voices_menu
words = []
while True:
try:
word = input('type text to search:\n')
if not word:
break
words.append(word)
except KeyboardInterrupt:
break
print('fetching...')
voices = SelectionMenu([])
i = 0
for text, id in get_audio(words):
i += 1
sel = SelectionMenu([], 'Choose phrase')
si = SubmenuItem(text[:60], sel, voices)
sel.append_item(FunctionItem(f"Play \"{text[:80]}\"",
play_wrapper(id)))
sel.append_item(FunctionItem(f"Save \"{text[:80]}\"",
save_wrapper(id)))
voices.append_item(si)
voices.title = f'Tip for long outputs: to exit press `1` and arrow up'
string = '+'.join(words)
submenu_item = SubmenuItem(f'Found {string} voices: {i}', voices, root)
root.append_item(submenu_item)
def build(self):
for recipe in self.recipes:
if recipe.link:
item = FunctionItem(recipe.title, url_open, args=[recipe.link])
else:
item = FunctionItem(recipe.title,
lambda x: print(x),
args=[self.error_msg])
self.menu.append_item(item)
def submenu_logging(menu_obj):
submenu = CursesMenu("Logging Configuration")
q1_item = FunctionItem("Do you want to turn enable logging?", input,
['yes'])
q2_item = FunctionItem(
"If yes, do you want logging to stdout or a log file?", input,
['FILE'])
submenu.append_item(q1_item)
submenu.append_item(q2_item)
submenu_item = SubmenuItem("Show a submenu", submenu, menu=menu_obj)
return submenu_item
def create_menu(list_dict_stories, type_new):
title = 'Pynews - {} stories'.format(type_new.capitalize())
menu = CursesMenu(title, 'Select the new and press enter')
msg = 'This new does not have an URL'
for story in list_dict_stories:
title = clean_title(story['title'])
if 'url' in story:
item = FunctionItem(title, url_open, args=[story['url']])
else:
item = FunctionItem(title, lambda x: print(x), args=[msg])
menu.append_item(item)
return menu
def submenu_backup(menu_obj):
submenu = CursesMenu("Access Key Backup")
q1_item = FunctionItem(
"Do you want to retain a copy of newly created access keys?", input,
["yes"])
q2_item = FunctionItem(
"Enter the directory where a backup copy of the access keys should be stored",
input, ["~/Backup"])
submenu.append_item(q1_item)
submenu.append_item(q2_item)
submenu_item = SubmenuItem("Show a submenu", submenu, menu=menu_obj)
return submenu_item
def test_run(self):
mock_function_1 = MagicMock(name="mock_function_1", return_value=5)
mock_function_2 = MagicMock(name="mock_function_2", return_value=10)
args = [1, 2, 3]
kwargs = {"end": "\n", "sep": " "}
function_item_1 = FunctionItem("function_item_1", mock_function_1)
function_item_2 = FunctionItem("function_item_2", mock_function_2, args, kwargs)
function_item_1.action()
function_item_2.action()
self.assertEqual(function_item_1.get_return(), 5)
self.assertEqual(function_item_2.get_return(), 10)
mock_function_1.assert_any_call()
mock_function_2.assert_called_once_with(*args, **kwargs)
def generate_menu(menu=None, menu_cfg=None, parent_title=None):
if not menu_cfg:
menu_cfg = c.get_menu()
if not menu:
title = get_string(menu_cfg, 'title')
subtitle = get_string(menu_cfg, 'subtitle', params=parent_title)
menu = CursesMenu(title, subtitle)
options = menu_cfg['options']
if type(options) == str and get_string(menu_cfg, 'type') == 'submenu':
options_list = c.get_config()[options]
for option in options_list:
if 'on_item_select' in menu_cfg:
title = get_string(menu_cfg, 'title')
subtitle = get_string(menu_cfg['on_item_select'], 'subtitle', params=option)
submenu = CursesMenu(title, subtitle)
option_menu = generate_menu(menu_cfg=menu_cfg['on_item_select'], parent_title=option)
item = SubmenuItem(option, option_menu, menu=submenu)
else:
item = FunctionItem(option, getattr(c.get_action_module(), menu_cfg['action']), [option]) # TODO allow for customisation of module name
menu.append_item(item)
else:
for option in menu_cfg['options']:
cmd_type = get_string(option, 'type')
title = get_string(option, 'title')
action = get_string(option, 'action')
subtitle = get_string(option, 'subtitle')
if cmd_type == 'function':
item = FunctionItem(title, getattr(actions, action))
elif cmd_type == 'submenu':
submenu = CursesMenu(title, subtitle)
item = SubmenuItem(title, submenu, menu=menu)
generate_menu(submenu, option, title)
else:
item = MenuItem(title)
menu.append_item(item)
return menu
def parse_old_menu(menu_data):
"""
Take an old-style menuData dictionary and return a CursesMenu
:param dict menu_data:
:return: A new CursesMenu
:rtype: CursesMenu
"""
menu_title = menu_data['title']
menu = CursesMenu(menu_title)
for item in menu_data["options"]:
item_type = item["type"]
item_title = item["title"]
if item_type == menuItem.COMMAND:
item_command = item["command"]
menu.append_item(CommandItem(item_title, item_command, menu))
elif item_type == menuItem.FUNCTION:
item_function = item["function"]
menu.append_item(FunctionItem(item_title, item_function, menu))
elif item_type == menuItem.EXITMENU:
menu.append_item(ExitItem(item_title, menu))
elif item_type == menuItem.NUMBER:
menu.append_item(SelectionItem(item_title, menu))
elif item_type == menuItem.MENU:
new_menu = parse_old_menu(item)
menu.append_item(SubmenuItem(item_title, menu, new_menu))
return menu
def step_impl(context):
context.menu = CursesMenu("Test Menu", "Subtitle")
context.menu_item = MenuItem("NORMAL", "Menu Item")
context.menu.append_item(context.menu_item)
context.function_item = FunctionItem("NORMAL", "Call a Python function",
input, ["Enter an input"])
context.menu.append_item(context.function_item)
pass
def main_menu():
# create the menu object
this_menu = CursesMenu("Teamwork Time", "Menu")
# create the menu items
rebuild_projects = FunctionItem("Rebuild Project Cache", get_projects,
[instance, project_ids, config])
select_project = FunctionItem("Select Project",
select_projects, [config],
should_exit=True)
# build the menu
this_menu.append_item(rebuild_projects)
this_menu.append_item(select_project)
# show the menu
this_menu.show()
this_menu.clear_screen()
return select_project.get_return()
def test_run(self):
mock_function_1 = MagicMock(name="mock_function_1", return_value=5)
mock_function_2 = MagicMock(name="mock_function_2", return_value=10)
args = [1, 2, 3]
kwargs = {"end": "\n", "sep": " "}
function_item_1 = FunctionItem("function_item_1", mock_function_1)
function_item_2 = FunctionItem("function_item_2", mock_function_2, args, kwargs)
function_item_1.action()
function_item_2.action()
self.assertEqual(function_item_1.get_return(), 5)
self.assertEqual(function_item_2.get_return(), 10)
mock_function_1.assert_any_call()
mock_function_2.assert_called_once_with(*args, **kwargs)
def test_init(self):
function_item_1 = FunctionItem("function_item_1", fun1)
function_item_2 = FunctionItem("function_item_2", fun1, ["-l", "-a", "~"], {"test": 12}, self.menu, True)
function_item_3 = FunctionItem(text="function_item_3", function=fun2, args=[1, 2, 3],
kwargs={1: "thing", 16: "other"}, menu=self.menu, should_exit=False)
self.assertEqual(function_item_1.text, "function_item_1")
self.assertEqual(function_item_2.text, "function_item_2")
self.assertEqual(function_item_3.text, "function_item_3")
self.assertIsNone(function_item_1.menu)
self.assertEqual(function_item_2.menu, self.menu)
self.assertEqual(function_item_3.menu, self.menu)
self.assertFalse(function_item_1.should_exit)
self.assertTrue(function_item_2.should_exit)
self.assertFalse(function_item_3.should_exit)
self.assertEqual(function_item_1.function, fun1)
self.assertEqual(function_item_2.function, fun1)
self.assertEqual(function_item_3.function, fun2)
self.assertEqual(function_item_1.args, [])
self.assertEqual(function_item_2.args, ["-l", "-a", "~"])
self.assertEqual(function_item_3.args, [1, 2, 3])
self.assertEqual(function_item_1.kwargs, {})
self.assertEqual(function_item_2.kwargs, {"test": 12})
self.assertEqual(function_item_3.kwargs, {1: "thing", 16: "other"})
def create_menu(self) -> None:
# Create the menu
self.menu = CursesMenu("PyMeterReader Configuration Wizard",
"Choose item to configure")
function_item = FunctionItem("Volkszähler Gateway",
self.input_gw, ["Enter URL: "],
should_exit=True)
self.menu.append_item(function_item)
for meter in self.meters:
meter_menu = CursesMenu(
f"Connect channels for meter {meter.meter_id} at {meter.meter_address}",
"By channel")
for channel in meter.channels:
map_menu = CursesMenu(
f"Choose uuid for {channel.channel_name}")
for choice in self.gateway_channels:
map_menu.append_item(
FunctionItem(f"{choice.uuid}: {choice.title}",
self.__assign,
[meter, channel, choice.uuid, '30m'],
should_exit=True))
map_menu.append_item(
FunctionItem("Enter private UUID",
self.__assign, [meter, channel, None, '30m'],
should_exit=True))
meter_menu.append_item(
SubmenuItem(
f"{channel.channel_name}: {channel.value} {channel.unit}",
map_menu, self.menu))
submenu_item = SubmenuItem(f"Meter {meter.meter_id}", meter_menu,
self.menu)
self.menu.append_item(submenu_item)
view_item = FunctionItem("View current mapping", self.__view_mapping)
self.menu.append_item(view_item)
save_item = FunctionItem("Save current mapping", self.__safe_mapping)
self.menu.append_item(save_item)
register_service = FunctionItem(
"Register PymeterReader as systemd service.",
self.__register_service)
self.menu.append_item(register_service)
reset_item = FunctionItem("Reset all mappings", self.__clear)
self.menu.append_item(reset_item)
self.menu.show()
def step_impl(context):
context.menu = CursesMenu("Test Menu", "Subtitle")
context.menu_item = MenuItem("NORMAL", "Menu Item")
context.menu.append_item(context.menu_item)
context.function_item = FunctionItem("NORMAL", "Call a Python function",
input, ["Enter an input"])
context.menu.append_item(context.function_item)
context.command_item = CommandItem("NORMAL", "Run a console command",
"ipconfig /all")
context.menu.append_item(context.command_item)
context.selection_menu = SelectionMenu(["item1", "item2", "item3"])
context.selection_submenu_item = SubmenuItem("NORMAL", "Submenu item",
context.selection_menu)
context.menu.append_item(context.selection_submenu_item)
pass
def show_menu(self):
self.menu = CursesMenu('bust - Module Editor', self.set_subtitle())
self.menu.append_item(FunctionItem('Edit name', self.edit_name))
self.menu.append_item(
FunctionItem('List registers', self.list_registers))
self.menu.append_item(
FunctionItem('Add new register', self.add_register))
self.menu.append_item(
FunctionItem('Remove register', self.remove_register))
self.menu.append_item(
FunctionItem('Update addresses', self.update_addresses))
self.menu.append_item(FunctionItem('Save JSON', self.save_JSON))
self.menu.show()
def step_impl(context):
context.function_item = FunctionItem("NORMAL", "Call a Python function",
input, ["Enter an input"])
context.menu.append_item(context.function_item)
pass
break
words.append(word)
except KeyboardInterrupt:
break
print('fetching...')
voices = SelectionMenu([])
i = 0
for text, id in get_audio(words):
i += 1
sel = SelectionMenu([], 'Choose phrase')
si = SubmenuItem(text[:60], sel, voices)
sel.append_item(FunctionItem(f"Play \"{text[:80]}\"",
play_wrapper(id)))
sel.append_item(FunctionItem(f"Save \"{text[:80]}\"",
save_wrapper(id)))
voices.append_item(si)
voices.title = f'Tip for long outputs: to exit press `1` and arrow up'
string = '+'.join(words)
submenu_item = SubmenuItem(f'Found {string} voices: {i}', voices, root)
root.append_item(submenu_item)
root = SelectionMenu([], title='Welcome to GLaDOS voice management system')
root.append_item(FunctionItem("Search for GLaDOS voices", placeholder))
try:
root.show(show_exit_option=True)
except:
restore()
menu.append_item(submenu_logging)
menu.show()
user_selection = menu.selected_option
except Exception as e:
print('Unknown Exception: %s. Exit' % str(e))
return False
return True
if __name__ == '__main__':
menu = CursesMenu("Local Configuration Menu", "xlines Project")
# backup
submenu = CursesMenu("Exclusions",
'Do you want to add a new file type exclusion?')
q1_item1 = FunctionItem("Yes", input, ["yes"])
q1_item2 = FunctionItem("No", print('Exit'), ["no"])
submenu.append_item(q1_item1)
submenu.append_item(q1_item2)
submenu_exclusions = SubmenuItem("Configure Exclusion List",
submenu,
menu=menu)
menu.append_item(submenu_exclusions)
if q1_item1 == "yes":
display_exclusions()
submenu = CursesMenu(
"Access Key Backup",
'Enter the directory where a backup copy of the access keys should be stored'
)
q2_item1 = FunctionItem("~/Backup/", input, ["~/Backup"])
submenu.append(q2_item1)
def step_impl(context):
context.append_item(FunctionItem("WHITE", "Start HCI", start_hci))
context.show()
pass
# Example copied from pypi.org/project/curses-menu/
# Import the necessary packages
from cursesmenu import CursesMenu, SelectionMenu
from cursesmenu.items import MenuItem, FunctionItem, CommandItem, SubmenuItem
# Create the menu
menu = CursesMenu("Title", "Subtitle")
# Create some items
# MenuItem is the base class for all items, it doesn't do anything when selected
menu_item = MenuItem("Menu Item")
# A FunctionItem runs a Python function when selected
function_item = FunctionItem("Call a Python function", input,
["Enter an input"])
# A CommandItem runs a console command
command_item = CommandItem("Run a console command", "touch hello.txt")
# A SelectionMenu constructs a menu from a list of strings
selection_menu = SelectionMenu(["item1", "item2", "item3"])
# A SubmenuItem lets you add a menu (the selection_menu above, for example)
# as a submenu of another menu
submenu_item = SubmenuItem("Submenu item", selection_menu, menu)
# Once we're done creating them, we just add the items to the menu
menu.append_item(menu_item)
menu.append_item(function_item)
menu.append_item(command_item)
#!/usr/bin/env python3
from cursesmenu import CursesMenu
from cursesmenu.items import FunctionItem
dtitle = "default title"
menu = CursesMenu(dtitle)
def myFunc():
menu.title = "there's a new title"
# myFunc, the'()' were not allowed here, got TypeError str
function_item = FunctionItem("change title", myFunc)
menu.append_item(function_item)
menu.show()
