def returns_on_enter_runner(self, contents, num_elements, exp_return1, exp_return2): lb = Listbox(contents, get_mock_input(), get_mock_output(), name=lb_name, config={}) lb.refresh = lambda *args, **kwargs: None # Checking at the start of the list def scenario(): lb.select_entry() # KEY_ENTER assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert return_value == exp_return1 # Checking at the end of the list def scenario(): for i in range(num_elements - 1): lb.move_down() # KEY_DOWN x2 lb.select_entry() # KEY_ENTER assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert return_value == exp_return2
def __init__(self, i, o): super(LoadingBarExampleApp, self).__init__(i, o) self.menu_name = "Loading bar test app" self.default_progress_bar = ProgressBar(self.i, self.o) self.text_progress_bar = TextProgressBar(self.i, self.o, refresh_interval=.1, show_percentage=True, percentage_offset=0) self.circular_progress = CircularProgressBar(self.i, self.o, show_percentage=True) self.dotted_progress_bar = IdleDottedMessage(self.i, self.o) self.throbber = Throbber(self.i, self.o, message="Test message") self.graphical_progress_bar = GraphicalProgressBar(self.i, self.o) self.default_progress_bar = ProgressBar(self.i, self.o) lb_contents = [ ["Default progress bar", self.default_progress_bar], ["Text progress bar", self.text_progress_bar], ["Dotted idle ", self.dotted_progress_bar], ["Circular progress ", self.circular_progress], ["Idle Throbber", self.throbber], ["Graphical Loading bar", self.graphical_progress_bar], ] self.bar_choice_listbox = Listbox(lb_contents, self.i, self.o)
def test_left_key_returns_none(self): """ A Listbox shouldn't return anything when LEFT is pressed""" num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] lb = Listbox(contents, get_mock_input(), get_mock_output(), name=lb_name, config={}) lb.refresh = lambda *args, **kwargs: None # Checking at the start of the list def scenario(): lb.deactivate() # KEY_LEFT assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert return_value is None # Checking at the end of the list def scenario(): for i in range(num_elements): lb.move_down() # KEY_DOWN x3 lb.deactivate() # KEY_LEFT assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert return_value is None
def callback(): listbox_contents = [ ["NumberAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 101], ["String", "stringstring"], ["Tuple", (1, 2, 3)]] lb = Listbox(listbox_contents, i, o) HelpOverlay(lambda: print("Halp plz")).apply_to(lb) lb.activate()
def graphical_display_redraw_runner(self, contents): o = get_mock_graphical_output() lb = Listbox(contents, get_mock_input(), o, name=lb_name, config={}) Canvas.fonts_dir = fonts_dir # Exiting immediately, but we should get at least one redraw def scenario(): lb.deactivate() # KEY_LEFT assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert o.display_image.called assert o.display_image.call_count == 1 #One in to_foreground
def set_timezone(self): try: with open('/etc/timezone', "r") as f: current_timezone = f.readline().strip() except: logger.exception("Can't get current timezone!") current_timezone = None else: logger.info("Current timezone: {}".format(repr(current_timezone))) lc = [] with LoadingBar(self.i, self.o, message="Getting timezones"): for k in ZoneInfoFile(getzoneinfofile_stream()).zones.keys(): lc.append([k]) lc = sorted(lc) choice = Listbox(lc, self.i, self.o, "Timezone selection listbox", selected=current_timezone).activate() if choice: # Setting timezone using timedatectl try: check_output(["timedatectl", "set-timezone", choice]) except CalledProcessError as e: logger.exception( "Can't set timezone using timedatectl! Return code: {}, output: {}" .format(e.returncode, repr(e.output))) return False else: logger.info("Set timezone successfully") return True else: return None
def change_wifi_country(self): with open('/usr/share/zoneinfo/iso3166.tab') as f: content = f.readlines() lc = [] current_country = self.get_current_wifi_country() for l in content: # Replace tabs with spaces and strip newlines l = l.replace('\t', ' ').strip() # Filter commented-out lines if l.startswith("#"): continue country_code, description = l.split(' ', 1) lc.append([rfa(l), country_code]) choice = Listbox(lc, self.i, self.o, name="WiFi country selection listbox", selected=current_country).activate() if choice: with LoadingBar(self.i, self.o, message="Changing WiFi country", name="WiFi country change LoadingBar"): result = self.set_wifi_country(choice) if result: Printer("Changed the country successfully!", self.i, self.o) return True else: Printer("Failed to change the country!", self.i, self.o) return False return None
def pick_bootloader(self): """ A menu to pick the bootloader from bootloaders.json. Also records fuse information in self.write_fuse_params, where it stays until user selects another bootloader or manually selects a file by path. """ bootloader_dir = local_path("bootloaders/") config = read_config( os.path.join(bootloader_dir, self.bootloader_config_filename)) bootloader_choices = [[bootloader["name"], bootloader] for bootloader in config["bootloaders"]] if not bootloader_choices: PrettyPrinter("No bootloaders found!", self.i, self.o, 3) return choice = Listbox(bootloader_choices, self.i, self.o, name="Avrdude bootloader picker").activate() if choice: self.write_file = os.path.join(bootloader_dir, choice["file"]) self.write_fuse_params = [] for type in self.fuse_types: if type in choice: self.write_fuse_params.append( [type, choice[type], config["fuse_format"]]) self.config["last_write_file"] = self.write_file self.config["last_write_fuse_params"] = self.write_fuse_params self.save_config()
def selected_single_el_entry_runner(self, contents, selected): lb = Listbox(contents, get_mock_input(), get_mock_output(), selected=selected, name=lb_name, config={}) lb.refresh = lambda *args, **kwargs: None # Checking at the start of the list def scenario(): lb.select_entry() # KEY_ENTER assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: return_value = lb.activate() assert return_value == selected
def test_constructor(self): """tests constructor""" lb = Listbox([["Option", "option"]], get_mock_input(), get_mock_output(), name=lb_name, config={}) self.assertIsNotNone(lb)
def change_difficulty(): global speed, level lc = [["Too young to die", 1], ["Hurt me plenty", 2], ["Nightmare !", 3]] selected_level = Listbox(lc, i, o, name="Level").activate() # If user presses Left, Listbox returns None if selected_level: level = selected_level if level == 3: speed = 0.05
def select_adjust_type(): global config contents = [["Percent", '%'], ["Decibels", 'dB'], ["HW value", '']] adjust_type = Listbox(contents, i, o, "Adjust selection listbox").activate() if adjust_type is None: return False config["adjust_type"] = adjust_type write_config(config, config_path)
def test_left_key_works_when_not_exitable(self): """Listbox should still exit on KEY_LEFT when exitable is set to False""" num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] lb = Listbox(contents, get_mock_input(), get_mock_output(), name=lb_name, config={}) lb.refresh = lambda *args, **kwargs: None def scenario(): assert "KEY_LEFT" in lb.keymap lb.deactivate() assert not lb.in_foreground with patch.object(lb, 'idle_loop', side_effect=scenario) as p: lb.activate()
def shows_data_on_screen_runner(self, contents): i = get_mock_input() o = get_mock_output() lb = Listbox(contents, i, o, name=lb_name, config={}) def scenario(): lb.deactivate() with patch.object(lb, 'idle_loop', side_effect=scenario) as p: lb.activate() #The scenario should only be called once assert lb.idle_loop.called assert lb.idle_loop.call_count == 1 assert o.display_data.called assert o.display_data.call_count == 1 #One in to_foreground assert o.display_data.call_args[0] == ('A0', 'A1', 'A2', lb.exit_entry[0])
def test_contents(self): """tests contents str-to-list replacement""" lb = Listbox([["Option", "option1"], "option2"], get_mock_input(), get_mock_output(), name=lb_name, config={}) self.assertIsNotNone(lb.contents) for entry in lb.contents: assert (isinstance(entry, list))
def test_keymap(self): """tests keymap""" lb = Listbox([["Option", "option"]], get_mock_input(), get_mock_output(), name=lb_name, config={}) self.assertIsNotNone(lb.keymap) for key_name, callback in lb.keymap.iteritems(): self.assertIsNotNone(callback)
def __init__(self, i, o): super(LoadingBarExampleApp, self).__init__(i, o) self.menu_name = "Loading bar test app" self.progress_bar = ProgressBar( self.i, self.o, refresh_interval=.1, show_percentage=True, percentage_offset=0, keymap={"KEY_RIGHT": self.increase_progress}) self.dotted_progress_bar = DottedProgressIndicator(self.i, self.o, refresh_interval=.1) lb_contents = [["Progress bar", self.progress_bar], ["Dotted bar", self.dotted_progress_bar]] self.bar_choice_listbox = Listbox(lb_contents, self.i, self.o)
def test_exit_label_leakage(self): """tests whether the exit label of one Listbox leaks into another""" i = get_mock_input() o = get_mock_output() c1 = Listbox([["a", "1"]], i, o, name=lb_name + "1", final_button_name="Name1", config={}) c2 = Listbox([["b", "2"]], i, o, name=lb_name + "2", final_button_name="Name2", config={}) c3 = Listbox([["c", "3"]], i, o, name=lb_name + "3", config={}) assert (c1.exit_entry != c2.exit_entry) assert (c2.exit_entry != c3.exit_entry) assert (c1.exit_entry != c3.exit_entry)
def select_channel(): global config contents = [] channels = amixer_get_channels() for channel in channels: contents.append([ellipsize(channel, o.cols), channel]) channel = Listbox(contents, i, o, "Channel selection listbox").activate() if channel is None: return False config["channel"] = channel write_config(config, config_path)
def select_card(): #TODO get a list of all cards global config contents = [] cards = [] for card in cards: contents.append([ellipsize(card["name"], o.cols), card["id"]]) card_id = Listbox(contents, i, o, "Card selection listbox").activate() if card_id is None: return False config["card"] = card_id write_config(config, config_path)
def flash_image_ui(): if not MTKDownloadProcess(None, None, path=config["mtkdownload_path"]).mtkdownload_is_available(): Printer("mtkdownload not found!", i, o, 5) choice = DialogBox("yn", i, o, name="Hardware setup app mtkdownload path confirmation", message="Set mtkdownload path?").activate() if choice: if set_mtkdownload_path(): # Running again, now the path should be valid flash_image_ui() return # No need to continue whether we've recursed or not, exiting files = collect_fw_folders(config["gsm_fw_path"]) lbc = [[os.path.basename(file), file] for file in files] if not lbc: Printer("No firmware images found!", i, o, 5) choice = DialogBox("yn", i, o, name="Hardware setup app mtkdownload path confirmation", message="Alternative FW path?").activate() if choice: if set_sim_firmware_path(): # Running again, now there should be some firmware flash_image_ui() return choice = Listbox(lbc, i, o, name="Hardware setup app GSM FW picker").activate() # A ProgressBar for the flashing specifically pb = ProgressBar(i, o, message="Flashing the modem") # A LoadingIndicator for everything else li = LoadingIndicator(i, o, message="Waiting for modem") if choice: cb = lambda state: process_state(pb, li, state) p = MTKDownloadProcess("/dev/ttyAMA0", choice, callback=cb, path=config["mtkdownload_path"]) gp = get_gsm_reset_gpio() if not gp: return def reset(): gpio.setup(gp, gpio.OUT) gpio.set(gp, False) sleep(0.1) gpio.set(gp, True) e = None try: p.write_image(reset_cb=reset) except Exception as e: e = traceback.format_exc() state = p.get_state() if state["state"] == "failed" or e: choice = DialogBox("yn", i, o, message="Send bugreport?").activate() if choice: br = BugReport("mtkdownload_flash_fail.zip") if e: br.add_text(json.dumps(e), "mtkdownload_exception.json") br.add_text(json.dumps(p.dump_info()), "mtkdownload_psinfo.json") result = br.send_or_store("/boot/", logger=logger) if result[0]: logger.info("Report sent to {}".format(result[1])) else: logger.info("Report stored in {}".format(result[1]))
def get_gsm_reset_gpio(): hw_revs = [["Gamma", "gamma"], ["Delta/Delta-B", "delta"]] gpios = {"gamma":502, "delta":496} assert(all([hwr[1] in gpios.keys() for hwr in hw_revs])) # check after editing hwr = Listbox(hw_revs, i, o, name="Hardware setup app GSM FW picker").activate() if not hwr: return None if hwr == "delta": # Enable UARTs gpio.setup(500, gpio.OUT) gpio.set(500, False) gp = gpios[hwr] return gp
def init_app(input, output): global callback, i, o i = input o = output lb_contents = [["Very long listbox option name", 1], ["Even longer option name", 2]] lb = Listbox(lb_contents, i, o, "Scrolling test listbox") pp = PathPicker('/', i, o) main_menu_contents = [["Command with very long name", lb.activate], ["Command with an even longer name", pp.activate], ["Exit", 'exit']] main_menu = Menu(main_menu_contents, i, o, "Scrolling test menu") callback = main_menu.activate
def remove_entry_menu(): # Kinda misleading, since it's a Listbox cl = context.list_contexts() gmnfa = get_menu_name_for_alias lc = [[gmnfa(cl, entry), entry] for entry in config["app_open_entries"] if gmnfa(cl, entry)] if not lc: PrettyPrinter("No app open entries found!", i, o, 3) return choice = Listbox( lc, i, o, name="Zeromenu app open entry removal menu").activate() if choice: config["app_open_entries"].remove(choice) save_config(config)
def add_entry_menu(): cl = context.list_contexts() app_context_list = [entry for entry in cl if entry["menu_name"]] lc = [[e["menu_name"], e["name"]] for e in app_context_list] lc = list(sorted(lc)) if not lc: PrettyPrinter("No suitable app contexts found!", i, o, 3) return choice = Listbox( lc, i, o, name="Zeromenu app open entry addition menu").activate() if choice: config["app_open_entries"].append(choice) save_config(config)
def pick_chip(self): """ A menu to pick the chip from a list of available chips provided by avrdude. """ chips = pyavrdude.get_parts() lc = [[name, alias] for alias, name in chips.items()] choice = Listbox(lc, self.i, self.o, "Avrdude part picker listbox", selected=self.current_chip).activate() if choice: self.current_chip = choice self.config["default_part"] = self.current_chip self.save_config()
def pick_programmer(self): """ A menu to pick the programmer from a list of available programmers provided by avrdude. """ programmers = pyavrdude.get_programmers() if self.filter_programmers: programmers = self.get_filtered_programmers(programmers) lc = [[name, alias] for alias, name in programmers.items()] choice = Listbox(lc, self.i, self.o, "Avrdude programmer picker listbox", selected=self.current_programmer).activate() if choice: self.current_programmer = choice self.config["default_programmer"] = self.current_programmer self.save_config()
def get_hw_version(li): if rpiinfo.is_pi_zero(): if rpiinfo.is_pi_zero_w(): return "zerow" else: return "zero" else: with li.paused: if vcgencmd.otp_problem_detected(vcgencmd.otp_dump()): TextReader(otp_fail_text, i, o, h_scroll=False).activate() else: Printer("Hardware detect failed! Pick your hardware:", i, o, 5) lc = [["Pi Zero", "zero"], ["Pi Zero W", "zerow"], ["Other", "other"]] choice = Listbox( lc, i, o, name="WiFi repair - hw revision picker").activate() return choice
def pick_branch(self): #TODO: allow adding branches dynamically instead of having a whitelist lc = [[branch_name] for branch_name in self.config["branches"]] branch = Listbox( lc, i, o, name="Git updater branch selection listbox").activate() if branch: try: GitInterface.checkout(branch) self.check_revisions = False updated = self.update() self.check_revisions = True except: PrettyPrinter( "Couldn't check out the {} branch! Try resolving the conflict through the command-line." .format(branch), i, o, 3) else: PrettyPrinter("Now on {} branch!".format(branch), i, o, 2) self.suggest_restart()
def set_hw_version(offer_zpui_restart=True): lbc = sorted([list(reversed(x)) for x in versions.items()]) choice = Listbox(lbc, i, o, name="ZP hardware version choose listbox").activate() if choice: try: result = hw_version.set_version(choice) except: logger.exception("Exception while setting hardware version") result = False if result: Printer("Success!", i, o) if offer_zpui_restart: needs_restart = DialogBox('yn', i, o, message="Restart ZPUI?").activate() if needs_restart: os.kill(os.getpid(), signal.SIGTERM) else: Printer("Failed to set the version =( Please send a bugreport", i, o, 7) return result