efibootdude 0.0__py3-none-any.whl

efibootdude/PowerWindow.py

@@ -0,0 +1,740 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Custom Wrapper for python curses.
+"""
+# pylint: disable=too-many-instance-attributes,too-many-arguments
+# pylint: disable=invalid-name,broad-except,too-many-branches
+
+# pylint: disable=wrong-import-position,disable=wrong-import-order
+# import VirtEnv
+# VirtEnv.ensure_venv(__name__)
+
+import traceback
+import atexit
+import signal
+import time
+import curses
+import textwrap
+from types import SimpleNamespace
+from curses.textpad import rectangle, Textbox
+dump_str = None
+
+def ignore_ctrl_c():
+    """" Ignore SIGINT """
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+def restore_ctrl_c():
+    """" Handle SIGINT """
+    signal.signal(signal.SIGINT, signal.default_int_handler)
+
+class OptionSpinner:
+    """Manage a bunch of options where the value is rotate thru
+    a fixed set of values pressing a key."""
+    def __init__(self):
+        """Give the object with the attribute to change its
+        value (e.g., options from argparse or "self" from
+        the object managing the window).
+
+        And array of specs like:
+            ['a - allow auto suggestions', 'allow_auto', True, False],
+            ['/ - filter pattern', 'filter_str', self.filter_str],
+        A spec can have a trailing None + more comments shown after
+        the value.
+        """
+        self.options, self.keys = [], []
+        self.margin = 4 # + actual width (1st column right pos)
+        self.align = self.margin # + actual width (1st column right pos)
+        self.default_obj = SimpleNamespace() # if not given one
+        self.attr_to_option = {} # given an attribute, find its option ns
+        self.key_to_option = {} # given key, options namespace
+        self.keys = set()
+
+    @staticmethod
+    def _make_option_ns():
+        return SimpleNamespace(
+            keys=[],
+            descr='',
+            obj=None,
+            attr='',
+            vals=None,
+            prompt=None,
+            comments=[],
+        )
+
+    def get_value(self, attr, coerce=False):
+        """Get the value of the given attribute."""
+        ns = self.attr_to_option.get(attr, None)
+        obj = ns.obj if ns else None
+        value = getattr(obj, attr, None) if obj else None
+        if value is None and obj and coerce:
+            if ns.vals:
+                if value not in ns.vals:
+                    value = ns.vals[0]
+                    setattr(obj, attr, value)
+            else:
+                if value is None:
+                    value = ''
+                    setattr(ns.obj, ns.attr, '')
+        return value
+
+    def _register(self, ns):
+        """ Create the mappings needed"""
+        assert ns.attr not in self.attr_to_option
+        self.attr_to_option[ns.attr] = ns
+        for key in ns.keys:
+            assert key not in self.key_to_option, f'key ({chr(key)}, {key}) already used'
+            self.key_to_option[key] = ns
+            self.keys.add(key)
+        self.options.append(ns)
+        self.align = max(self.align, self.margin+len(ns.descr))
+        self.get_value(ns.attr, coerce=True)
+
+    def add(self, obj, specs):
+        """ Compatibility Method."""
+        for spec in specs:
+            ns = self._make_option_ns()
+            ns.descr = spec[0]
+            ns.obj = obj
+            ns.attr = spec[1]
+            ns.vals=spec[2:]
+            if None in ns.vals:
+                idx = ns.vals.index(None)
+                ns.vals = ns.vals[:idx]
+                ns.comments = ns.vals[idx+1:]
+            ns.keys = [ord(ns.descr[0])]
+            self._register(ns)
+
+    def add_key(self, attr, descr, obj=None, vals=None, prompt=None, keys=None, comments=None):
+        """ Standard method"""
+        ns = self._make_option_ns()
+        if keys:
+            ns.keys = list(keys) if isinstance(keys, (list, tuple, set)) else [keys]
+        else:
+            ns.keys = [ord(descr[0])]
+        if comments is None:
+            ns.comments = []
+        else:
+            ns.comments = list(comments) if isinstance(keys, (list, tuple)) else [comments]
+        ns.descr = descr
+        ns.attr = attr
+        ns.obj = obj if obj else self.default_obj
+        ns.vals, ns.prompt = vals, prompt
+        assert bool(ns.vals) ^ bool(ns.prompt)
+        self._register(ns)
+
+    @staticmethod
+    def show_help_nav_keys(win):
+        """For help screens, show the navigation keys. """
+        for line in Window.get_nav_keys_blurb().splitlines():
+            if line:
+                win.add_header(line)
+
+    def show_help_body(self, win):
+        """ Write the help page section."""
+        win.add_body('Type keys to alter choice:', curses.A_UNDERLINE)
+
+        for ns in self.options:
+            # get / coerce the current value
+            value = self.get_value(ns.attr)
+            assert value is not None, f'cannot get value of {repr(ns.attr)}'
+            choices = ns.vals if ns.vals else [value]
+
+            win.add_body(f'{ns.descr:>{self.align}}: ')
+
+            for choice in choices:
+                shown = f'{choice}'
+                if isinstance(choice, bool):
+                    shown = "ON" if choice else "off"
+                win.add_body(' ', resume=True)
+                win.add_body(shown, resume=True,
+                    attr=curses.A_REVERSE if choice == value else None)
+
+            for comment in ns.comments:
+                win.add_body(f'{"":>{self.align}}:  {comment}')
+
+    def do_key(self, key, win):
+        """Do the automated processing of a key."""
+        ns = self.key_to_option.get(key, None)
+        if ns is None:
+            return None
+        value = self.get_value(ns.attr)
+        if ns.vals:
+            idx = ns.vals.index(value) if value in ns.vals else -1
+            value = ns.vals[(idx+1) % len(ns.vals)] # choose next
+        else:
+            value = win.answer(prompt=ns.prompt, seed=str(value))
+        setattr(ns.obj, ns.attr, value)
+        return value
+
+class Window:
+    """ Layer above curses to encapsulate what we need """
+    timeout_ms = 200
+    static_scr = None
+    nav_keys = """
+        Navigation:    H/M/L:   top/middle/end-of-page
+            k, UP:  up one row               0, HOME:  first row
+          j, DOWN:  down one row              $, END:  last row
+           Ctrl-u:  half-page up       Ctrl-b, PPAGE:  page up
+           Ctrl-d:  half-page down     Ctrl-f, NPAGE:  page down
+    """
+    def __init__(self, head_line=True, head_rows=50, body_rows=200,
+                 body_cols=200, keys=None, pick_mode=False, pick_size=1,
+                 mod_pick=None):
+        self.scr = self._start_curses()
+
+        self.head = SimpleNamespace(
+            pad=curses.newpad(head_rows, body_cols),
+            rows=head_rows,
+            cols=body_cols,
+            row_cnt=0,  # no. head rows added
+            texts = [],
+            view_cnt=0,  # no. head rows viewable (NOT in body)
+        )
+        self.body = SimpleNamespace(
+            pad = curses.newpad(body_rows, body_cols),
+            rows= body_rows,
+            cols=body_cols,
+            row_cnt = 0,
+            texts = []
+        )
+        self.mod_pick = mod_pick # call back to modify highlighted row
+        self.hor_line_cnt = 1 if head_line else 0 # no. h-lines in header
+        self.scroll_pos = 0  # how far down into body are we?
+        self.max_scroll_pos = 0
+        self.pick_pos = 0 # in highlight mode, where are we?
+        self.last_pick_pos = -1 # last highlighted position
+        self.pick_mode = pick_mode # whether in highlight mode
+        self.pick_size = pick_size # whether in highlight mode
+        self.rows, self.cols = 0, 0
+        self.body_cols, self.body_rows = body_cols, body_rows
+        self.scroll_view_size = 0  # no. viewable lines of the body
+        self.handled_keys = set(keys) if isinstance(keys, (set, list)) else []
+        self._set_screen_dims()
+        self.calc()
+        
+    def get_pad_width(self):
+        # how much space to actually draw chars?
+        return min(self.cols-1, self.body_cols)
+
+    @staticmethod
+    def get_nav_keys_blurb():
+        """For a help screen, describe the nav keys"""
+        return textwrap.dedent(Window.nav_keys)
+
+    def _set_screen_dims(self):
+        """Recalculate dimensions ... return True if geometry changed."""
+        rows, cols = self.scr.getmaxyx()
+        same = bool(rows == self.rows and cols == self.cols)
+        self.rows, self.cols = rows, cols
+        return same
+
+    @staticmethod
+    def _start_curses():
+        """ Curses initial setup.  Note: not using curses.wrapper because we
+        don't wish to change the colors. """
+        atexit.register(Window.stop_curses)
+        ignore_ctrl_c()
+        Window.static_scr = scr = curses.initscr()
+        curses.noecho()
+        curses.cbreak()
+        curses.curs_set(0)
+        scr.keypad(1)
+        scr.timeout(Window.timeout_ms)
+        scr.clear()
+        return scr
+
+    def set_pick_mode(self, on=True, pick_size=1):
+        """Set whether in highlight mode."""
+        was_on, was_size = self.pick_mode, self.pick_size
+        self.pick_mode = bool(on)
+        self.pick_size = max(pick_size, 1)
+        if self.pick_mode and (not was_on or was_size != self.pick_size):
+            self.last_pick_pos = -2 # indicates need to clear them all
+
+    @staticmethod
+    def stop_curses():
+        """ Curses shutdown (registered to be called on exit). """
+        if Window.static_scr:
+            curses.nocbreak()
+            curses.echo()
+            Window.static_scr.keypad(0)
+            curses.endwin()
+            Window.static_scr = None
+            restore_ctrl_c()
+
+    def calc(self):
+        """Recalculate dimensions ... return True if geometry changed."""
+        same = self._set_screen_dims()
+        self.head.view_cnt = min(self.rows - self.hor_line_cnt, self.head.row_cnt)
+        self.scroll_view_size = self.rows - self.head.view_cnt - self.hor_line_cnt
+        self.max_scroll_pos = max(self.body.row_cnt - self.scroll_view_size, 0)
+        self.body_base = self.head.view_cnt + self.hor_line_cnt
+        return not same
+
+    def _put(self, ns, *args):
+        """ Add text to head/body pad using its namespace. args:
+            - bytes (converted to str/unicode)
+            - str (unicode)
+            - None (same as curses.A_NORMAL)
+            - int (curses attribute)
+        """
+        def flush(attr=None):
+            nonlocal self, is_body, row, text, seg, first
+            if (is_body and self.pick_mode) or attr is None:
+                attr = curses.A_NORMAL
+            if seg and first:
+                ns.pad.addstr(row, 0, seg[0:self.get_pad_width()], attr)
+            elif seg:
+                _, x = ns.pad.getyx()
+                cols = self.get_pad_width() - x
+                if cols > 0:
+                    ns.pad.addstr(seg[0:cols], attr)
+            text += seg
+            seg, first, attr = '', False, None
+
+        is_body = bool(id(ns) == id(self.body))
+        if ns.row_cnt < ns.rows:
+            row = max(ns.row_cnt, 0)
+            text, seg, first = '', '', True
+            for arg in args:
+                if isinstance(arg, bytes):
+                    arg = arg.decode('utf-8')
+                if isinstance(arg, str):
+                    seg += arg  # note: add w/o spacing
+                elif arg is None or isinstance(arg, (int)):
+                    # assume arg is attribute ... flushes text
+                    flush(attr=arg)
+            flush()
+            ns.texts.append(text)  # text only history
+            ns.row_cnt += 1
+
+    def put_head(self, *args):
+        """ Put a line above the line."""
+        self._put(self.head, *args)
+
+    def put_body(self, *args):
+        """ Put a line below the line."""
+        self._put(self.body, *args)
+
+    def _add(self, ns, text, attr=None, resume=False):
+        """ Add text to head/body pad using its namespace"""
+        is_body = bool(id(ns) == id(self.body))
+        if ns.row_cnt < ns.rows:
+            row = max(ns.row_cnt - (1 if resume else 0), 0)
+            if (is_body and self.pick_mode) or attr is None:
+                attr = curses.A_NORMAL
+            if resume:
+                _, x = ns.pad.getyx()
+                cols = self.get_pad_width() - x
+                if cols > 0:
+                    ns.pad.addstr(text[0:cols], attr)
+                    ns.texts[row] += text
+            else:
+                ns.pad.addstr(row, 0, text[0:self.cols], attr)
+                ns.texts.append(text)  # text only history
+                ns.row_cnt += 1
+
+    def add_header(self, text, attr=None, resume=False):
+        """Add text to header"""
+        self._add(self.head, text, attr, resume)
+
+    def add_body(self, text, attr=None, resume=False):
+        """ Add text to body (below header and header line)"""
+        self._add(self.body, text, attr, resume)
+
+    def draw(self, y, x, text, text_attr=None, width=None, leftpad=False, header=False):
+        """Draws the given text (as utf-8 or unicode) at position (row=y,col=x)
+        with optional text attributes and width.
+        This is more compatible with my older, simpler Window class.
+        """
+        ns = self.head if header else self.body
+        text_attr = text_attr if text_attr else curses.A_NORMAL
+        if y < 0 or y >= ns.rows or x < 0 or x >= ns.cols:
+            return # nada if out of bounds
+        ns.row_cnt = max(ns.row_cnt, y+1)
+
+        uni = text if isinstance(text, str) else text.decode('utf-8')
+
+        if width is not None:
+            width = min(width, self.get_pad_width() - x)
+            if width <= 0:
+                return
+            padlen = width - len(uni)
+            if padlen > 0:
+                if leftpad:
+                    uni = padlen * ' ' + uni
+                else:  # rightpad
+                    uni += padlen * ' '
+            text = uni[:width].encode('utf-8')
+        else:
+            text = uni.encode('utf-8')
+
+        try:
+            while y >= len(ns.texts):
+                ns.texts.append('')
+            ns.texts[y] = ns.texts[y][:x].ljust(x) + uni + ns.texts[y][x+len(uni):]
+            ns.pad.addstr(y, x, text, text_attr)
+        except curses.error:
+            # this sucks, but curses returns an error if drawing the last character
+            # on the screen always.  this can happen if resizing screen even if
+            # special care is taken.  So, we just ignore errors.  Anyhow, you cannot
+            # get decent error handling.
+            pass
+
+
+    def highlight_picked(self):
+        """Highlight the current pick and un-highlight the previous pick."""
+        def get_text(pos):
+            nonlocal self
+            return self.body.texts[pos][0:self.cols] if pos < len(self.body.texts) else ''
+
+        if not self.pick_mode:
+            return
+        pos0, pos1 = self.last_pick_pos, self.pick_pos
+        if pos0 == -2: # special flag to clear all formatting
+            for row in range(self.body.row_cnt):
+                line = get_text(row).ljust(self.get_pad_width())
+                self.body.pad.addstr(row, 0, get_text(row), curses.A_NORMAL)
+        if pos0 != pos1:
+            if 0 <= pos0 < self.body.row_cnt:
+                for i in range(self.pick_size):
+                    line = get_text(pos0+i).ljust(self.get_pad_width())
+                    self.body.pad.addstr(pos0+i, 0, line, curses.A_NORMAL)
+            if 0 <= pos1 < self.body.row_cnt:
+                for i in range(self.pick_size):
+                    line = get_text(pos1+i)
+                    if self.mod_pick:
+                        line = self.mod_pick(line)
+                    line = line.ljust(self.get_pad_width())
+                    self.body.pad.addstr(pos1+i, 0, line, curses.A_REVERSE)
+                self.last_pick_pos = pos1
+
+    def _scroll_indicator_row(self):
+        """ Compute the absolute scroll indicator row:
+        - We want the top to be only when scroll_pos==0
+        - We want the bottom to be only when scroll_pos=max_scroll_pos-1
+        """
+        if self.max_scroll_pos <= 1:
+            return self.body_base
+        y2, y1 = self.scroll_view_size-1, 1
+        x2, x1 = self.max_scroll_pos, 1
+        x = self.scroll_pos
+        pos = y1 + (y2-y1)*(x-x1)/(x2-x1)
+        return min(self.body_base + int(max(pos, 0)), self.rows-1)
+
+    def _scroll_indicator_col(self):
+        """ Compute the absolute scroll indicator col:
+        - We want the left to be only when scroll_pos==0
+        - We want the right to be only when scroll_pos=max_scroll_pos-1
+        """
+        if self.pick_mode:
+            return self._calc_indicator(
+                self.pick_pos, 0, self.body.row_cnt-1, 0, self.cols-1)
+        return self._calc_indicator(
+            self.scroll_pos, 0, self.max_scroll_pos, 0, self.cols-1)
+
+    def _calc_indicator(self, pos, pos0, pos9, ind0, ind9):
+        if self.max_scroll_pos <= 0:
+            return -1 # not scrollable
+        if pos9 - pos0 <= 0:
+            return -1 # not scrollable
+        if pos <= pos0:
+            return ind0
+        if pos >= pos9:
+            return ind9
+        ind = int(round(ind0 + (ind9-ind0+1)*(pos-pos0)/(pos9-pos0+1)))
+        return min(max(ind, ind0+1), ind9-1)
+
+    def render(self):
+        """Draw everything added. In a loop cuz curses is a
+        piece of shit."""
+        for _ in range(128):
+            try:
+                self.render_once()
+                return
+            except curses.error:
+                time.sleep(0.16)
+                self._set_screen_dims()
+                continue
+        try:
+            self.render_once()
+        except Exception:
+            Window.stop_curses()
+            print(f"""curses err:
+    head.row_cnt={self.head.row_cnt}
+    head.view_cnt={self.head.view_cnt}
+    hor_line_cnt={self.hor_line_cnt}
+    body.row_cnt={self.body.row_cnt}
+    scroll_pos={self.scroll_pos}
+    max_scroll_pos={self.max_scroll_pos}
+    pick_pos={self.pick_pos}
+    last_pick_pos={self.last_pick_pos}
+    pick_mode={self.pick_mode}
+    pick_size={self.pick_size}
+    rows={self.rows}
+    cols={self.cols}
+""")
+            raise
+
+
+    def fix_positions(self, delta=0):
+        """ Ensure the vertical positions are on the playing field """
+        self.calc()
+        # if self.scroll_view_size <= 0:
+            # self.scr.refresh()
+        if self.pick_mode:
+            self.pick_pos += delta
+        else:
+            self.scroll_pos += delta
+            self.pick_pos += delta
+
+        indent = 0
+        if self.body_base < self.rows:
+            ind_pos = 0 if self.pick_mode else self._scroll_indicator_row()
+            if self.pick_mode:
+                self.pick_pos = max(self.pick_pos, 0)
+                self.pick_pos = min(self.pick_pos, self.body.row_cnt-1)
+                if self.pick_pos >= 0:
+                    self.pick_pos -= (self.pick_pos % self.pick_size)
+                if self.pick_pos < 0:
+                    self.scroll_pos = 0
+                elif self.scroll_pos > self.pick_pos:
+                    # light position is below body bottom
+                    self.scroll_pos = self.pick_pos
+                elif self.scroll_pos < self.pick_pos - (self.scroll_view_size - self.pick_size):
+                    # light position is above body top
+                    self.scroll_pos = self.pick_pos - (self.scroll_view_size - self.pick_size)
+                self.scroll_pos = max(self.scroll_pos, 0)
+                self.scroll_pos = min(self.scroll_pos, self.max_scroll_pos)
+                indent = 1
+            else:
+                self.scroll_pos = max(self.scroll_pos, 0)
+                self.scroll_pos = min(self.scroll_pos, self.max_scroll_pos)
+                self.pick_pos = self.scroll_pos + ind_pos - self.body_base
+                # indent = 1 if self.body.row_cnt > self.scroll_view_size else 0
+        return indent
+
+    def render_once(self):
+        """Draw everything added."""
+
+        indent = self.fix_positions()
+
+        if indent > 0 and self.pick_mode:
+            self.scr.vline(self.body_base, 0, ' ', self.scroll_view_size)
+            if self.pick_pos >= 0:
+                pos = self.pick_pos - self.scroll_pos + self.body_base
+                self.scr.addstr(pos, 0, '>', curses.A_REVERSE)
+
+        if self.head.view_cnt < self.rows:
+            self.scr.hline(self.head.view_cnt, 0, curses.ACS_HLINE, self.cols)
+            ind_pos = self._scroll_indicator_col()
+            if ind_pos >= 0:
+                bot, cnt = ind_pos, 1
+                if 0 < ind_pos < self.cols-1:
+                    width = self.scroll_view_size/self.body.row_cnt*self.cols
+                    bot = max(int(round(ind_pos-width/2)), 1)
+                    top = min(int(round(ind_pos+width/2)), self.cols-1)
+                    cnt = top - bot
+                # self.scr.addstr(self.head.view_cnt, bot, '-'*cnt, curses.A_REVERSE)
+                # self.scr.hline(self.head.view_cnt, bot, curses.ACS_HLINE, curses.A_REVERSE, cnt)
+                for idx in range(bot, bot+cnt):
+                    self.scr.addch(self.head.view_cnt, idx, curses.ACS_HLINE, curses.A_REVERSE)
+
+        self.scr.refresh()
+
+        if self.body_base < self.rows:
+            if self.pick_mode:
+                self.highlight_picked()
+            self.body.pad.refresh(self.scroll_pos, 0,
+                  self.body_base, indent, self.rows-1, self.cols-1)
+
+        if self.rows > 0:
+            last_row = min(self.head.view_cnt, self.rows)-1
+            if last_row >= 0:
+                self.head.pad.refresh(0, 0, 0, indent, last_row, self.cols-1)
+
+
+    def answer(self, prompt='Type string [then Enter]', seed='', width=80):
+        """Popup"""
+        def mod_key(key):
+            return  7 if key == 10 else key
+
+        # need 3 extra cols for rectangle (so we don't draw in southeast corner)
+        # and 3 rows (top/prompt/bottom)
+        #      +Prompt---    -----------------+
+        #      | Seed-for-answer              |
+        #      +---------Press ENTER to submit+
+        if self.rows < 3 or self.cols < 30:
+            return seed
+        width = min(width, self.cols-3) # max text width
+        row0, row9 = self.rows//2 - 1, self.rows//2 + 1
+        col0 = (self.cols - (width+2)) // 2
+        col9 = col0 + width + 2 - 1
+
+        self.scr.clear()
+        win = curses.newwin(1, width, row0+1, col0+1) # input window
+        rectangle(self.scr, row0, col0, row9, col9)
+        self.scr.addstr(row0, col0+1, prompt[0:width])
+        win.addstr(seed[0:width-1])
+        ending = 'Press ENTER to submit'[:width]
+        self.scr.addstr(row9, col0+1+width-len(ending), ending)
+        self.scr.refresh()
+        curses.curs_set(2)
+        answer = Textbox(win).edit(mod_key).strip()
+        curses.curs_set(0)
+        return answer
+
+    def alert(self, title='ALERT', message='', height=1, width=80):
+        """Alert box"""
+        def mod_key(key):
+            return  7 if key in (10, curses.KEY_ENTER) else key
+
+        # need 3 extra cols for rectangle (so we don't draw in southeast corner)
+        # and 3 rows (top/prompt/bottom)
+        #      +Prompt---    -----------------+
+        #      | First line for message...    |
+        #      | Last line for message.       |
+        #      +-----------Press ENTER  to ack+
+        if self.rows < 2+height or self.cols < 30:
+            return
+        width = min(width, self.cols-3) # max text width
+        row0 = (self.rows+height-1)//2 - 1
+        row9 = row0 + height + 1
+        col0 = (self.cols - (width+2)) // 2
+        col9 = col0 + width + 2 - 1
+
+        self.scr.clear()
+        for row in range(self.rows):
+            self.scr.insstr(row, 0, ' '*self.cols, curses.A_REVERSE)
+        pad = curses.newpad(20, 200)
+        win = curses.newwin(1, 1, row9-1, col9-2) # input window
+        rectangle(self.scr, row0, col0, row9, col9)
+        self.scr.addstr(row0, col0+1, title[0:width], curses.A_REVERSE)
+        pad.addstr(message)
+        ending = 'Press ENTER to ack'[:width]
+        self.scr.addstr(row9, col0+1+width-len(ending), ending)
+        self.scr.refresh()
+        pad.refresh(0, 0, row0+1, col0+1, row9-1, col9-1)
+        Textbox(win).edit(mod_key).strip()
+        return
+
+    def clear(self):
+        """Clear in prep for new screen"""
+        self.scr.clear()
+        self.head.pad.clear()
+        self.body.pad.clear()
+        self.head.texts, self.body.texts, self.last_pick_pos = [], [], -1
+        self.head.row_cnt = self.body.row_cnt = 0
+
+    def prompt(self, seconds=1.0):
+        """Here is where we sleep waiting for commands or timeout"""
+        ctl_b, ctl_d, ctl_f, ctl_u = 2, 4, 6, 21
+        elapsed = 0.0
+        while elapsed < seconds:
+            key = self.scr.getch()
+            if key == curses.ERR:
+                elapsed += self.timeout_ms / 1000
+                continue
+            if key in (curses.KEY_RESIZE, ) or curses.is_term_resized(self.rows, self.cols):
+                # self.scr.erase()
+                self._set_screen_dims()
+                # self.render()
+                break
+
+            # App keys...
+            if key in self.handled_keys:
+                return key # return for handling
+
+            # Navigation Keys...
+            pos = self.pick_pos if self.pick_mode else self.scroll_pos
+            delta = self.pick_size if self.pick_mode else 1
+            was_pos = pos
+            if key in (ord('k'), curses.KEY_UP):
+                pos -= delta
+            elif key in (ord('j'), curses.KEY_DOWN):
+                pos += delta
+            elif key in (ctl_b, curses.KEY_PPAGE):
+                pos -= self.scroll_view_size
+            elif key in (ctl_u, ):
+                pos -= self.scroll_view_size//2
+            elif key in (ctl_f, curses.KEY_NPAGE):
+                pos += self.scroll_view_size
+            elif key in (ctl_d, ):
+                pos += self.scroll_view_size//2
+            elif key in (ord('0'), curses.KEY_HOME):
+                pos = 0
+            elif key in (ord('$'), curses.KEY_END):
+                pos = self.body.row_cnt - 1
+            elif key in (ord('H'), ):
+                pos = self.scroll_pos
+            elif key in (ord('M'), ):
+                pos = self.scroll_pos + self.scroll_view_size//2
+            elif key in (ord('L'), ):
+                pos = self.scroll_pos + self.scroll_view_size-1
+
+            if self.pick_mode:
+                self.pick_pos = pos
+            else:
+                self.scroll_pos = pos
+                self.pick_pos = pos
+
+            self.fix_positions()
+
+            if pos != was_pos:
+                self.render()
+            # ignore unhandled keys
+        return None
+
+def no_runner():
+    """Appease sbrun"""
+
+if __name__ == '__main__':
+    def main():
+        """Test program"""
+        def do_key(key):
+            nonlocal spin, win, opts
+            value = spin.do_key(key, win)
+            if key in (ord('p'), ord('s')):
+                win.set_pick_mode(on=opts.pick_mode, pick_size=opts.pick_size)
+            elif key == ord('n'):
+                win.alert(title='Info', message=f'got: {value}')
+            return value
+
+        spin = OptionSpinner()
+        spin.add_key('help_mode', '? - toggle help screen', vals=[False, True])
+        spin.add_key('pick_mode', 'p - toggle pick mode', vals=[False, True])
+        spin.add_key('pick_size', 's - #rows in pick', vals=[1, 2, 3])
+        spin.add_key('name', 'n - select name', prompt='Provide Your Name:')
+        spin.add_key('mult', 'm - row multiplier', vals=[0.5, 0.9, 1.0, 1.1, 2, 4, 16])
+        opts = spin.default_obj
+
+        win = Window(head_line=True, keys=spin.keys)
+        opts.name = "[hit 'n' to enter name]"
+        for loop in range(100000000000):
+            body_size = int(round(win.scroll_view_size*opts.mult))
+            if opts.help_mode:
+                win.set_pick_mode(False)
+                spin.show_help_nav_keys(win)
+                spin.show_help_body(win)
+            else:
+                win.set_pick_mode(opts.pick_mode, opts.pick_size)
+                win.add_header(f'Header: {loop} "{opts.name}"')
+                for idx, line in enumerate(range(body_size//opts.pick_size)):
+                    win.add_body(f'Main pick: {loop}.{line}')
+                    for num in range(1, opts.pick_size):
+                        win.draw(num+idx*opts.pick_size, 0, f'  addon: {loop}.{line}')
+            win.render()
+            _ = do_key(win.prompt(seconds=5))
+            win.clear()
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        pass
+    except Exception as exce:
+        Window.stop_curses()
+        print("exception:", str(exce))
+        print(traceback.format_exc())
+        if dump_str:
+            print(dump_str)

efibootdude/main.py

@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Interactive, visual thin layer atop efibootmgr
+"""
+# pylint: disable=broad-exception-caught,consider-using-with
+# pylint: disable=too-many-instance-attributes,too-many-branches
+# pylint: disable=too-many-return-statements,too-many-statements
+# pylint: disable=consider-using-in,too-many-nested-blocks
+# pylint: disable=wrong-import-position,disable=wrong-import-order
+# pylint: disable=too-many-locals
+
+import os
+import sys
+import re
+import shutil
+from types import SimpleNamespace
+import subprocess
+import traceback
+import curses as cs
+import xml.etree.ElementTree as ET
+from efibootdude.PowerWindow import Window, OptionSpinner
+
+
+class EfiBootDude:
+    """ Main class for curses atop efibootmgr"""
+    singleton = None
+
+    def __init__(self):
+        # self.cmd_loop = CmdLoop(db=False) # just running as command
+        assert not EfiBootDude.singleton
+        EfiBootDude.singleton = self
+
+        spin = self.spin = OptionSpinner()
+        spin.add_key('help_mode', '? - toggle help screen', vals=[False, True])
+        spin.add_key('verbose', 'v - toggle verbose', vals=[False, True])
+
+        # FIXME: keys
+        other = 'tudrnmwf*zqx'
+        other_keys = set(ord(x) for x in other)
+        other_keys.add(cs.KEY_ENTER)
+        # other_keys.add(27) # ESCAPE
+        other_keys.add(10) # another form of ENTER
+        self.opts = spin.default_obj
+
+        self.actions = {} # currently available actions
+        self.check_preqreqs()
+        self.mounts, self.uuids = {}, {}
+        self.mods = SimpleNamespace()
+        self.digests, self.width1, self.label_wid, self.boot_idx = [], 0, 0, 0
+        self.win = None
+        self.reinit()
+        self.win = Window(head_line=True, body_rows=len(self.digests)+20, head_rows=10,
+                          keys=spin.keys ^ other_keys, mod_pick=self.mod_pick)
+        self.win.pick_pos = self.boot_idx
+
+    def reinit(self):
+        """ RESET EVERYTHING"""
+        self.mounts = self.get_mounts()
+        self.uuids = self.get_part_uuids() # uuid in lower case
+        self.mods = SimpleNamespace(
+                    dirty=False, # if anything changed
+                    order=False,
+                    timeout=None,
+                    removes=set(),
+                    tags={},
+#                   adds=set(),
+                    next=None,
+                    actives=set(),
+                    inactives=set(),
+                    )
+        self.digests, self.width1, self.label_wid, self.boot_idx = [], 0, 0, 0
+        self.digest_boots()
+        if self.win:
+            self.win.pick_pos = self.boot_idx
+
+    @staticmethod
+    def get_mounts():
+        """ Get a dictionary of device-to-mount-point """
+        mounts = {}
+        with open('/proc/mounts', 'r', encoding='utf-8') as mounts_file:
+            for line in mounts_file:
+                parts = line.split()
+                dev = parts[0]
+                mount_point = parts[1]
+                mounts[dev] = mount_point
+        return mounts
+
+    def get_part_uuids(self):
+        """ Get all the Partition UUIDS"""
+        uuids = {}
+        with open('/run/blkid/blkid.tab', encoding='utf8') as fh:
+            # sample: <device ... TYPE="vfat"
+            #   PARTUUID="25d2dea1-9f68-1644-91dd-4836c0b3a30a">/dev/nvme0n1p1</device>
+            for xml_line in fh:
+                element = ET.fromstring(xml_line)
+                if 'PARTUUID' in element.attrib:
+                    device=element.text.strip()
+                    name = self.mounts.get(device, device)
+                    uuids[element.attrib['PARTUUID'].lower()] = name
+        return uuids
+
+    @staticmethod
+    def extract_uuid(line):
+        """ Find uuid string in a line """
+        # Define the regex pattern for UUID (e.g., 25d2dea1-9f68-1644-91dd-4836c0b3a30a)
+        pattern = r'\b[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\b'
+        # Search for the pattern in the line
+        match = re.search(pattern, line, re.IGNORECASE)
+        return match.group(0).lower() if match else None
+
+
+    def digest_boots(self):
+        """ Digest the output of 'efibootmgr'."""
+        # Define the command to run
+        command = 'efibootmgr'.split()
+        # Run the command and capture the output
+        result = subprocess.run(command, stdout=subprocess.PIPE, text=True, check=True)
+        lines = result.stdout.splitlines()
+        rv = []
+        width1 = 0  # width of info1
+        label_wid = 0
+        boots = {}
+        for line in ['BootNext: ---'] + lines:
+            parts = line.split(maxsplit=1)
+            if len(parts) < 2:
+                continue
+            key, info = parts[0], parts[1]
+
+            if key == 'BootOrder:':
+                boot_order = info
+                continue
+
+            ns = SimpleNamespace(
+                ident=None,
+                is_boot=False,
+                active='',
+                label='',
+                info1='',
+                info2='',
+            )
+
+            mat = re.match(r'\bBoot([0-9a-f]+)\b(\*?)' # Boot0024*
+                           + r'\s+(\w.*\w)\s+' # Linux Boot Manager
+                           + r'\b(\w+\(.*)$', # HD(4,GPT,cd15e3b1-...
+                           line, re.IGNORECASE)
+            if not mat:
+                ns.ident = key
+                ns.label = info
+                if key == 'BootNext:' and len(rv) > 0:
+                    rv[0] = ns
+                else:
+                    rv.append(ns)
+                continue
+
+            ns.ident = mat.group(1)
+            ns.is_boot = True
+            ns.active = mat.group(2)
+            ns.label = mat.group(3)
+            label_wid = max(label_wid, len(ns.label))
+            other = mat.group(4)
+
+            mat = re.search(r'/?File\(([^)]*)\)', other, re.IGNORECASE)
+            device, subpath = '', '' # e.g., /boot/efi, \EFI\UBUNTU\SHIMX64.EFI
+            if mat:
+                subpath = mat.group(1) + ' '
+                start, end = mat.span()
+                other = other[:start] + other[end:]
+
+            uuid = self.extract_uuid(other)
+            if uuid and uuid in self.uuids:
+                device = self.uuids[uuid]
+
+            if device:
+                ns.info1 = device
+                ns.info2 = subpath if subpath else other
+                width1 = max(width1, len(ns.info1))
+            elif subpath:
+                ns.info1 = subpath
+                ns.info2 = other
+            else:
+                ns.info1 = other
+            boots[ns.ident] = ns
+
+        self.boot_idx = len(rv)
+        self.width1 = width1
+        self.label_wid = label_wid
+
+        for ident in boot_order.split(','):
+            if ident in boots:
+                rv.append(boots.pop(ident))
+        rv += list(boots.values())
+
+        self.digests = rv
+        return rv
+
+    @staticmethod
+    def check_preqreqs():
+        """ Check that needed programs are installed. """
+        ok = True
+        for prog in 'efibootmgr'.split():
+            if shutil.which(prog) is None:
+                ok = False
+                print(f'ERROR: cannot find {prog!r} on $PATH')
+        if not ok:
+            sys.exit(1)
+
+    @staticmethod
+    def get_word0(line):
+        """ Get words[1] from a string. """
+        words = line.split(maxsplit=1)
+        return words[0]
+
+    def write(self):
+        """ Commit the changes. """
+        if not self.mods.dirty:
+            return
+        cmds = []
+        prefix = 'sudo efibootmgr --quiet'
+        for ident in self.mods.removes:
+            cmds.append(f'{prefix} --delete-bootnum --bootnum {ident}')
+        for ident in self.mods.actives:
+            cmds.append(f'{prefix} --active --bootnum {ident}')
+        for ident in self.mods.inactives:
+            cmds.append(f'{prefix} --inactive --bootnum {ident}')
+        for ident, tag in self.mods.tags.items():
+            cmds.append(f'{prefix} --bootnum {ident} --label "{tag}"')
+        if self.mods.order:
+            orders = [ns.ident for ns in self.digests if ns.is_boot]
+            cmds.append(f'{prefix} --bootorder {','.join(orders)}')
+        if self.mods.next:
+            cmds.append(f'{prefix} --bootnext {self.mods.next}')
+        if self.mods.timeout:
+            cmds.append(f'{prefix} --timeout {self.mods.timeout}')
+        Window.stop_curses()
+        os.system('clear; stty sane')
+        print('Commands:')
+        for cmd in cmds:
+            print(f' + {cmd}')
+        yes = input("Run the above commands? (yes/No) ")
+
+        if yes.lower().startswith('y'):
+            os.system('/bin/echo; /bin/echo')
+
+            for cmd in cmds:
+                os.system(f'set -x; {cmd}; /bin/echo "    <<<ExitCode=$?>>>"')
+
+            os.system(r'/bin/echo -e "\n\n===== Press ENTER for menu ====> \c"; read FOO')
+            self.reinit()
+
+        Window._start_curses()
+        self.win.pick_pos = self.boot_idx
+
+
+
+    def main_loop(self):
+        """ TBD """
+
+        self.opts.name = "[hit 'n' to enter name]"
+        while True:
+            if self.opts.help_mode:
+                self.win.set_pick_mode(False)
+                self.spin.show_help_nav_keys(self.win)
+                self.spin.show_help_body(self.win)
+                # FIXME: keys
+                lines = [
+                    '   q or x - quit program (CTL-C disabled)',
+                    '   u - up - move boot entry up',
+                    '   d - down - move boot entry down',
+#                   '   c - copy - copy boot entry',
+                    '   r - remove - remove boot',
+#                   '   a - add - add boot entry',
+                    '   n - next - set next boot default',
+                    '   t - tag - set a new label for the boot entry',
+                    '   * - toggle whether entry is active'
+                    '   m - modify - modify the value'
+                    '   w - write - write the changes',
+                    '   f - freshen - clear changes and re-read boot state',
+                ]
+                for line in lines:
+                    self.win.put_body(line)
+            else:
+                # self.win.set_pick_mode(self.opts.pick_mode, self.opts.pick_size)
+                self.win.set_pick_mode(True)
+                self.win.add_header(self.get_keys_line(), attr=cs.A_BOLD)
+                for ns in self.digests:
+                    info1 = ns.info1
+                    if not self.opts.verbose:
+                        mat = re.search(r'/?VenHw\(.*$', info1, re.IGNORECASE)
+                        if mat:
+                            start, end = mat.span()
+                            info1 = info1[:start] + info1[end:]
+
+                    line = f'{ns.active:>1} {ns.ident:>4} {ns.label:<{self.label_wid}}'
+                    line += f' {info1:<{self.width1}} {ns.info2}'
+                    self.win.add_body(line)
+            self.win.render()
+
+            _ = self.do_key(self.win.prompt(seconds=300))
+            self.win.clear()
+
+    def get_keys_line(self):
+        """ TBD """
+        # EXPAND
+        line = ''
+        for key, verb in self.actions.items():
+            if key[0] == verb[0]:
+                line += f' {verb}'
+            else:
+                line += f' {key}:{verb}'
+        # or EXPAND
+        line += ' ?:help quit'
+        # for action in self.actions:
+            # line += f' {action[0]}:{action}'
+        return line[1:]
+
+    def get_actions(self):
+        """ Determine the type of the current line and available commands."""
+        # FIXME: keys
+        actions = {}
+        digests = self.digests
+        if 0 <= self.win.pick_pos < len(digests):
+            ns = digests[self.win.pick_pos]
+            if ns.is_boot:
+                if self.win.pick_pos > self.boot_idx:
+                    actions['u'] = 'up'
+                if self.win.pick_pos < len(self.digests)-1:
+                    actions['d'] = 'down'
+#               actions['c'] = 'copy'
+                actions['r'] = 'rmv'
+#               actions['a'] = 'add'
+                actions['n'] = 'next'
+                actions['t'] = 'tag'
+                actions['*'] = 'inact' if ns.active else 'act'
+            elif ns.ident in ('Timeout:', ):
+                actions['m'] = 'modify'
+            if self.mods.dirty:
+                actions['w'] = 'write'
+                actions['f'] = 'fresh'
+
+        return actions
+
+    @staticmethod
+    def mod_pick(line):
+        """ Callback to modify the "pick line" being highlighted;
+            We use it to alter the state
+        """
+        this = EfiBootDude.singleton
+        this.actions = this.get_actions()
+        header = this.get_keys_line()
+        wds = header.split()
+        this.win.head.pad.move(0, 0)
+        for wd in wds:
+            if wd:
+                this.win.add_header(wd[0], attr=cs.A_BOLD|cs.A_UNDERLINE, resume=True)
+            if wd[1:]:
+                this.win.add_header(wd[1:] + ' ', resume=True)
+
+        _, col = this.win.head.pad.getyx()
+        pad = ' ' * (this.win.get_pad_width()-col)
+        this.win.add_header(pad, resume=True)
+        return line
+
+    def do_key(self, key):
+        """ TBD """
+        if not key:
+            return True
+        if key == cs.KEY_ENTER or key == 10: # Handle ENTER
+            if self.opts.help_mode:
+                self.opts.help_mode = False
+                return True
+            return None
+
+        if key in self.spin.keys:
+            value = self.spin.do_key(key, self.win)
+            return value
+
+        if key in (ord('q'), ord('x')):
+            
+            answer = 'y'
+            if self.mods.dirty:
+                answer = self.win.answer(
+                    prompt='Enter "y" to abandon edits and exit [then Enter]')
+            if answer.strip().lower().startswith('y'):
+                self.win.stop_curses()
+                os.system('clear; stty sane')
+                sys.exit(0)
+            return None
+
+        ns = self.digests[self.win.pick_pos]
+
+        if key == ord('m'):
+            if ns.ident == 'Timeout:':
+                seed = ns.label.split()[0]
+                while True:
+                    answer = self.win.answer(
+                        prompt='Enter timeout seconds or clear to abort [then Enter]',
+                        seed=seed, width=80)
+                    seed = answer = answer.strip()
+                    if not answer:
+                        break
+                    if re.match(r'\d+$', answer):
+                        ns.label = f'{answer} seconds'
+                        self.mods.timeout = answer
+                        self.mods.dirty = True
+                        break
+            return None
+
+        if key == ord('u') and ns.is_boot:
+            digests, pos = self.digests, self.win.pick_pos
+            if pos > self.boot_idx:
+                digests[pos-1], digests[pos] = digests[pos], digests[pos-1]
+                self.win.pick_pos -= 1
+                self.mods.order = True
+                self.mods.dirty = True
+            return None
+        if key == ord('d') and ns.is_boot:
+            digests, pos = self.digests, self.win.pick_pos
+            if pos < len(self.digests)-1:
+                digests[pos+1], digests[pos] = digests[pos], digests[pos+1]
+                self.win.pick_pos += 1
+                self.mods.order = True
+                self.mods.dirty = True
+            return None
+        if key == ord('r') and ns.is_boot:
+            ident = self.digests[self.win.pick_pos].ident
+            del self.digests[self.win.pick_pos]
+            self.mods.removes.add(ident)
+            self.mods.actives.discard(ident)
+            self.mods.inactives.discard(ident)
+            self.mods.dirty = True
+            return None
+        if key == ord('n') and ns.is_boot:
+            ident = ns.ident
+            self.digests[0].label = ident
+            self.mods.next = ident
+            self.mods.dirty = True
+            return None
+
+        if key == ord('*') and ns.is_boot:
+            ident = ns.ident
+            if ns.active:
+                ns.active = ''
+                self.mods.actives.discard(ident)
+                self.mods.inactives.add(ident)
+            else:
+                ns.active = '*'
+                self.mods.actives.add(ident)
+                self.mods.inactives.discard(ident)
+            self.mods.dirty = True
+
+        if key == ord('t') and ns.is_boot:
+            seed = ns.label
+            while True:
+                answer = self.win.answer(prompt='Enter new label or clear to abort [then Enter], ',
+                    seed=seed, width=80)
+                seed = answer = answer.strip()
+                if not answer:
+                    break
+                if re.match(r'([\w\s])+$', answer):
+                    ns.label = f'{answer}'
+                    self.mods.tags[ns.ident] = answer
+                    self.mods.dirty = True
+                    break
+
+        if key == ord('f') and self.mods.dirty:
+            answer = self.win.answer(
+                prompt='Enter "y" to clear edits and refresh [then Enter]')
+            if answer.strip().lower().startswith('y'):
+                self.reinit()
+            return None
+
+        if key == ord('w') and self.mods.dirty:
+            self.write()
+            return None
+
+        # FIXME: handle more keys 
+        return None
+
+
+def main():
+    """ The program """
+
+    dude = EfiBootDude()
+    dude.main_loop()
+
+if __name__ == '__main__':
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        pass
+    except Exception as exce:
+        Window.stop_curses()
+        print("exception:", str(exce))
+        print(traceback.format_exc())
+#       if dump_str:
+#           print(dump_str)

efibootdude-0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Joe D
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

efibootdude-0.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: efibootdude
+Version: 0.0
+Summary: A visual wrapper for efibootmgr
+Author-email: Joe Defen <joedef@google.com>
+License: MIT
+Project-URL: Homepage, https://github.com/joedefen/efibootdude
+Project-URL: Bug Tracker, https://github.com/joedefen/efibootdude/issues
+Keywords: app,installer,manager,appimages
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil >=5.9
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+# EfiBootDude
+`efibootdude` presents a visual (curses) interface to `efibootmgr` which allows editing the bios
+boot menu and parameters while running Linux.
+
+* Install `efibootdude` using `pipx install efibootdude`, or however you do so.
+* Prerequisites: install [rhboot/efibootmgr](https://github.com/rhboot/efibootmgr)
+  * For example, on a Debian derived distro, use `sudo apt install efibootmgr`.
+
+
+`efibootdude` covers only the most commonly used capabilities of `efibootmgr` including:
+* reordering boot entries,
+* removing boot entries,
+* setting the boot entry for the next boot only,
+* setting boot entries active or inactive, and
+* setting the boot menu timeout value (until it boots the default entry).
+
+To be sure, there are many other esoteric uses of `efibootmanager`.
+  
+## Usage
+After running `efibootdude`, you'll see a screen like this:
+![efibootdude-screenshot](https://github.com/joedefen/efibootdude/blob/main/images/efibootdude-screenshot.png?raw=true).
+At this point
+* The current line starts with `>` and is highlighted.
+* The top line shows actions for the current line.
+* Enter `?` for a more complete explanation of the keys, navigation keys, etc.
+* With this current line, we can:
+  * Use `u` or `d` to move it up or down in the boot order.
+  * Use `t` to relabel the boot entry.
+  * Use `r` to remove it.
+  * And so forth.
+* When ready to write the changes to the BIOS, enter 'w'.
+* When writing the changes, `efibootdude` drops out of menu mode so you can
+  verify the underlying commands, error codes, and error messages.
+
+## Caveats
+* Some operations may not work permanently even though there is no indication from `efibootmgr`
+  (e.g., on my desktop, I cannot re-label boot entries).
+* Some operations may only work (again) after re-booting (e.g., you might find activating
+  an entry does not work, but it does so after a reboot).
+
+## About this Project
+This project was inspired by [Elinvention/efiboots](https://github.com/Elinvention/efiboots). Relative to that project, the aims of `efibootdude` are:
+* to be easier to install especially when not in your distro's repos.
+* to clearly present the partition of the boot entries (as a mount point if mounted and, otherwise, the device pathname).
+* to show the underlying commands being run for education, for verification, and for help on investigating issues.

efibootdude-0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+efibootdude/PowerWindow.py,sha256=pQGXsAMeuiHn-vtEiVG0rgW1eCslh3ukC-VrPhH_j3k,28587
+efibootdude/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+efibootdude/main.py,sha256=xl6_bKWJVxzbN31SUWUAWWI5DH5F_iX5HpR-i23JjJ0,17609
+efibootdude-0.0.dist-info/LICENSE,sha256=qB9OdnyyF6WYHiEIXVm0rOSdcf8e2ctorrtWs6CC5lU,1062
+efibootdude-0.0.dist-info/METADATA,sha256=hNAKcQp31odNUlDLHVZ41ngqLq19Y0WuttYgXw08ZtY,2995
+efibootdude-0.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+efibootdude-0.0.dist-info/entry_points.txt,sha256=3KZ_86ZSy4f-weuSruTlMGaQ96jZUm7mjyITVnjE184,54
+efibootdude-0.0.dist-info/top_level.txt,sha256=BrMsK3JmOrVJUNkHX1dicqWrdjbm4itRtmXJMxte-VU,12
+efibootdude-0.0.dist-info/RECORD,,

efibootdude-0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

efibootdude-0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+efibootdude = efibootdude.main:main

efibootdude-0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+efibootdude