backpack-backbone 0.3.1__tar.gz → 0.4.0__tar.gz

{backpack_backbone-0.3.1/backpack_backbone.egg-info → backpack_backbone-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backpack-backbone
-Version: 0.3.1
+Version: 0.4.0
 Summary: Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once.
 License: MIT
 Project-URL: Homepage, https://github.com/RedEraRrow/backbone
@@ -50,9 +50,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -61,8 +61,8 @@ at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -72,6 +72,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.
@@ -122,12 +129,16 @@ family (for typo scoring); raw key reads and escape decoding.
 through the same `_Widget` machinery every prompt widget uses, rather than each
 tool hand-rolling a redraw loop:
 
-    from backbone.prompt.core import run_dashboard
+    from backbone.prompt.chrome import chrome_room
+    from backbone.prompt.core import box_lines, run_dashboard
+    from backbone.ui import content_width
+
+    HINTS = [("q", "quit")]
 
     def render() -> list:
-        return ["  line one", "  line two"]
+        return box_lines(["line one", "line two"], content_width(), 4, "Status")
 
-    run_dashboard(render, interval=1.0, quit_key="q")
+    run_dashboard(render, interval=1.0, quit_action="list.quit", hints=HINTS)
 
 `render()` returns the whole frame as a list of lines, each carrying its own
 left indent, and only runs once per `interval`. Keypresses and resizes are
@@ -136,6 +147,10 @@ instead of waiting out the data-refresh cadence. `on_key` handles anything
 other than the quit key and is free to open a `select()` or `confirm()` of its
 own; the dashboard repaints from scratch when it returns.
 
+With `hints`, the hint bar goes under the frame as every other screen's does,
+with the help toggle and clickable keys; `chrome_room(hints)` is the rows the
+frame has above it. A window too small for boxes gets backbone's own notice.
+
 When stdin isn't a terminal (run from a script, or with input redirected),
 it falls back to a plain sleep loop and never reads keys, so such a view has
 to be stopped from outside.

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/README.md

@@ -32,9 +32,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -43,8 +43,8 @@ at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -54,6 +54,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.
@@ -104,12 +111,16 @@ family (for typo scoring); raw key reads and escape decoding.
 through the same `_Widget` machinery every prompt widget uses, rather than each
 tool hand-rolling a redraw loop:
 
-    from backbone.prompt.core import run_dashboard
+    from backbone.prompt.chrome import chrome_room
+    from backbone.prompt.core import box_lines, run_dashboard
+    from backbone.ui import content_width
+
+    HINTS = [("q", "quit")]
 
     def render() -> list:
-        return ["  line one", "  line two"]
+        return box_lines(["line one", "line two"], content_width(), 4, "Status")
 
-    run_dashboard(render, interval=1.0, quit_key="q")
+    run_dashboard(render, interval=1.0, quit_action="list.quit", hints=HINTS)
 
 `render()` returns the whole frame as a list of lines, each carrying its own
 left indent, and only runs once per `interval`. Keypresses and resizes are
@@ -118,6 +129,10 @@ instead of waiting out the data-refresh cadence. `on_key` handles anything
 other than the quit key and is free to open a `select()` or `confirm()` of its
 own; the dashboard repaints from scratch when it returns.
 
+With `hints`, the hint bar goes under the frame as every other screen's does,
+with the help toggle and clickable keys; `chrome_room(hints)` is the rows the
+frame has above it. A window too small for boxes gets backbone's own notice.
+
 When stdin isn't a terminal (run from a script, or with input redirected),
 it falls back to a plain sleep loop and never reads keys, so such a view has
 to be stopped from outside.

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/__init__.py

@@ -4,14 +4,9 @@ from .ui import (
     MARGIN_H,
     MARGIN_V,
     SPIN,
-    PARTS,
     SPARK,
     spinner,
     content_width,
-    rule,
-    bar,
-    header_box,
-    wrap_margins,
 )
 
 __all__ = [
@@ -19,12 +14,7 @@ __all__ = [
     "MARGIN_H",
     "MARGIN_V",
     "SPIN",
-    "PARTS",
     "SPARK",
     "spinner",
     "content_width",
-    "rule",
-    "bar",
-    "header_box",
-    "wrap_margins",
 ]

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/prompt/__init__.py

@@ -8,7 +8,7 @@ from backbone.prompt.core import (  # noqa: F401
 )
 from backbone.prompt.chrome import (  # noqa: F401
     CHROME_HANDLED, CHROME_REDRAW, MODE_TOGGLE, move_hint,
-    append_chrome, boxed_chrome, chrome_hint_lines, chrome_hint_pairs, consume_chrome, inner_rule,
+    append_chrome, boxed_chrome, chrome_hint_lines, chrome_room, chrome_hint_pairs, consume_chrome, inner_rule,
     disable_mouse, enable_mouse,
     open_command_line, set_activity_opener, set_command_line, set_player_opener, set_transport_handler,
 )
@@ -19,3 +19,7 @@ from backbone.prompt.dates import calendar_select, datetime_edit  # noqa: F401
 from backbone.prompt.values import fraction_edit, number_edit, rating_edit, time_edit  # noqa: F401
 from backbone.prompt.audio import equaliser_edit, rva2_edit  # noqa: F401
 from backbone.prompt.keymap import keys_editor  # noqa: F401
+from backbone.prompt.settings import (  # noqa: F401
+    ACCENT_COLUMNS, OFF_GLYPH, ON_GLYPH, SETTINGS_COLUMNS, accent_name, accent_swatch, index_of,
+    pick_accent, pick_option, space_toggles, state_glyph,
+)

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/prompt/chrome.py

@@ -20,6 +20,13 @@ keys.define("global", "Everywhere", [
     ("player", ("\x0f",), "open the player"),
     ("raw_text", ("\x14",), "switch a value between its editor and raw text"),
 ], within=())
+# The volume, on any screen that leaves these keys free (a list, the player,
+# the miniplayer; not a text field, where they're typed). Its own group, so a
+# key a screen binds for itself isn't taken from it.
+keys.define("volume", "Volume", [
+    ("up", ("+", "="), "volume up"),
+    ("down", ("-", "_"), "volume down"),
+], within=())
 
 # The one key pair that moves a row up or down, wherever a list's order can be
 # changed (select's on_move, list_edit).
@@ -108,20 +115,30 @@ CHROME_HANDLED = object()      # the key was consumed; carry on with the loop
 CHROME_REDRAW = object()       # consumed, and the caller should repaint fully
 
 
+def has_owner(action_id: str) -> bool:
+    """Whether an action does anything in this app: the transport and volume
+    keys need a transport handler installed, ^O a player to reopen. Every
+    other action belongs to a screen, so it does."""
+    if action_id in ("global.playpause", "global.next", "global.prev") or action_id.startswith("volume."):
+        return _transport_handler is not None
+    if action_id == "global.player":
+        return _player_opener is not None
+    return True
+
+
 def chrome_hint_pairs(pairs) -> list:
     """A widget's hint pairs plus the transport keys, while audio is playing.
 
-    Only keys that will actually do something are advertised: the transport trio
-    needs a handler installed and ^O needs a player to reopen. `unboxed` covers
+    Only keys that will actually do something are advertised (has_owner). `unboxed` covers
     a terminal too narrow to draw the now-playing box: the keys are still live,
     so they are still listed.
     """
     items = list(pairs.items()) if isinstance(pairs, dict) else [tuple(p) for p in pairs]
     if ui.footer_active() or ui.footer_unboxed():
-        if _transport_handler is not None:
+        if has_owner("global.playpause"):
             items += [(keys.label("global.playpause"), "play/pause"),
                       (keys.label("global.next", "global.prev"), "next/prev")]
-        if _player_opener is not None:
+        if has_owner("global.player"):
             items += [(keys.label("global.player"), "player")]
     return items
 
@@ -132,6 +149,12 @@ def chrome_hint_lines(pairs, *, extra: str = "") -> list:
     return _hint(*chrome_hint_pairs(pairs), extra=extra).splitlines()
 
 
+def chrome_room(pairs, *, extra: str = "") -> int:
+    """The rows a widget's frame has above its hint bar (append_chrome), for a
+    screen laying out its own boxes."""
+    return _hint_pin_target() - len(chrome_hint_lines(pairs, extra=extra))
+
+
 def append_chrome(out: list, pairs, cells: dict, *, extra: str = "",
                   pin: bool = True, help_key: bool = False) -> list:
     """Append the hint bar to a widget's rendered `out` lines, in place.
@@ -184,7 +207,7 @@ def boxed_chrome(body: list, title: str, pairs, cells: dict, *, extra: str = "",
         out = header + [f"  {C.DIM}{title}{C.RESET}"] + list(body)
         append_chrome(out, pairs, cells, extra=extra, help_key=help_key)
         return out, 0
-    box_h = max(3, _hint_pin_target() - len(header) - len(chrome_hint_lines(pairs, extra=extra)))
+    box_h = max(3, chrome_room(pairs, extra=extra) - len(header))
     out = boxed_frame(header, list(body), title, box_h, help_key and not header)
     append_chrome(out, pairs, cells, extra=extra, help_key=help_key)
     return out, 2
@@ -193,8 +216,8 @@ def boxed_chrome(body: list, title: str, pairs, cells: dict, *, extra: str = "",
 def consume_chrome(key: str, cells: dict, free_keys: bool = False):
     """Handle a transport key, a now-playing box click, a click on a hint key,
     or a click on the tab bar. With `free_keys` (a screen that has no other use
-    for them), also Tab / Shift-Tab and the digits for the tabs, and `:` for
-    the command line.
+    for them), also Tab / Shift-Tab and the digits for the tabs, `:` for the
+    command line, and the volume (+ / -).
 
     Returns :data:`CHROME_HANDLED` when the key is fully dealt with,
     :data:`CHROME_REDRAW` when the caller should also repaint, the synthesised
@@ -234,6 +257,10 @@ def consume_chrome(key: str, cells: dict, free_keys: bool = False):
     if act in ("global.playpause", "global.next", "global.prev") and _transport_handler is not None:
         _transport_handler(act.split(".")[1])
         return CHROME_HANDLED
+    vol = keys.action(key, "volume") if free_keys and isinstance(key, str) else None
+    if vol in ("volume.up", "volume.down") and _transport_handler is not None:
+        _transport_handler("vol_up" if vol == "volume.up" else "vol_down")
+        return CHROME_HANDLED
 
     if isinstance(key, str) and key.startswith('MOUSE_CLICK:'):
         parts = key.split(':')

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/prompt/core.py

@@ -590,7 +590,7 @@ def progress_float(message: str, progress: float) -> None:
     w = min(cols, _PROGRESS_W)
     boxed = rows >= 3 and w >= 16
     room = w - 4 if boxed else cols
-    bar = ui.get_progress_bar(progress, max(4, min(24, room // 3)))
+    bar = ui.get_progress_bar(progress, max(4, min(24, room // 3)), caps=not boxed)
     head = f"{ui.pulse_circle()} {bar} "
     text = head + C.DIM + ui.truncate_text(message, max(1, room - ui.visual_len(head))) + C.RESET
     text += " " * max(0, room - ui.visual_len(text))
@@ -914,6 +914,25 @@ def wheel_at() -> tuple | None:
     return _wheel_at[0]
 
 
+def _idle_tick() -> None:
+    """What every screen's wait does at ~8 Hz, and at once on a state change
+    (a pulse): the now-playing box repainted, a floating box taken away when
+    its time is up, and the background-activity notice kept live (re-stamped
+    while a task runs so its ● pulses; once more after the last, to clear it).
+    One routine for both, so frequent pulses (music playing) can't starve any
+    of it. Each part on its own: one failing mustn't stop the rest."""
+    _footer_last_draw[0] = time.time()
+    with quietly():
+        _render_footer_bar()
+    with quietly():
+        float_tick()
+    active = ui.has_background_tasks()
+    if active or _status_prev_active[0]:
+        with quietly():
+            render_status_bar()
+    _status_prev_active[0] = active
+
+
 def _wait_for_keypress(timeout: float = 0.05) -> bool:
     """Block up to `timeout` seconds for a keypress; return whether one arrived.
 
@@ -924,20 +943,8 @@ def _wait_for_keypress(timeout: float = 0.05) -> bool:
     if _cramped():
         _run_cramped()
         return False
-    now = time.time()
-    if now - _footer_last_draw[0] >= 0.12:
-        _footer_last_draw[0] = now
-        with quietly():
-            _render_footer_bar()
-            float_tick()
-        # Keep the background-activity notice live: while a task is running the
-        # status bar is re-stamped each tick so it stays up for the whole job and
-        # its cyan ● pulses; one extra redraw after the last task clears the bar.
-        active = ui.has_background_tasks()
-        if active or _status_prev_active[0]:
-            with quietly():
-                render_status_bar()
-        _status_prev_active[0] = active
+    if time.time() - _footer_last_draw[0] >= 0.12:
+        _idle_tick()
     if _IS_WINDOWS:
         end = time.time() + timeout
         while time.time() < end:
@@ -952,9 +959,7 @@ def _wait_for_keypress(timeout: float = 0.05) -> bool:
             os.read(_wake_r, 4096)        # drain all coalesced pulses
         except OSError:
             pass
-        _footer_last_draw[0] = time.time()    # this pulse counts as the tick
-        with quietly():
-            _render_footer_bar()     # repaint immediately on a state change
+        _idle_tick()                      # a state change: the tick's work now (the box repainted at once)
     return sys.stdin in ready             # a wake alone is not a keypress
 
 
@@ -2488,13 +2493,13 @@ hint = _hint   # the public name for the hint bar
 
 
 def run_dashboard(render, interval: float = 1.0, quit_action: str = "list.quit", on_quit=None,
-                  poll: float = 0.05, on_key=None) -> None:
+                  poll: float = 0.05, on_key=None, hints=None) -> None:
     """Runs a live, tick-driven view through a _Widget, so it resizes and
     paints like every other widget here. Returns when a key of the
     `quit_action` binding (see backbone.keys) is pressed.
 
     `render()` takes no arguments and returns the whole frame as a list of
-    lines, each carrying its own left-margin indent (see header_box()). It
+    lines, each carrying its own left-margin indent (box_lines() adds it). It
     runs once every `interval` seconds; keypresses and resizes are checked
     every `poll` seconds regardless, and a resize renders at once.
 
@@ -2506,6 +2511,12 @@ def run_dashboard(render, interval: float = 1.0, quit_action: str = "list.quit",
     back, raw mode undone) - the place for a "stop the background work
     too?" confirm().
 
+    `hints`, if given, are the view's (key, label) pairs, or a callable giving
+    them (for keys that can be rebound while it runs): they go in the hint
+    bar under the frame (append_chrome), which the help toggle and clicks on
+    its keys work like every other screen's. `render()` then lays its boxes
+    out in chrome_room(hints) rows.
+
     When stdin is not a terminal, keys can't be read: it renders on a plain
     time.sleep(interval) loop and never checks for the quit key, so the
     caller has to be stopped from outside.
@@ -2516,8 +2527,20 @@ def run_dashboard(render, interval: float = 1.0, quit_action: str = "list.quit",
     if is_tty:
         _set_raw(fd)
 
+    from backbone.prompt.chrome import (CHROME_HANDLED, CHROME_REDRAW, append_chrome,
+                                        consume_chrome, disable_mouse, enable_mouse)
+    cells: dict = {}
+
+    def frame() -> list:
+        lines = render()
+        if hints is None:
+            return lines
+        return append_chrome(lines, hints() if callable(hints) else hints, cells, help_key=True)
+
     w = _Widget(fd)
     screen_takeover_next()
+    if is_tty and hints is not None:
+        enable_mouse()
     last_render = 0.0
     try:
         while True:
@@ -2527,21 +2550,35 @@ def run_dashboard(render, interval: float = 1.0, quit_action: str = "list.quit",
                 w.anchor_reset()
             now = time.monotonic()
             if resized or now - last_render >= interval:
-                w.render(render())
+                w.render(frame())
                 last_render = now
             if is_tty:
                 if _wait_for_keypress(poll):
                     key = _read_key(fd)
+                    if hints is not None:
+                        chrome = consume_chrome(key, cells)
+                        if chrome is CHROME_HANDLED:
+                            continue
+                        if chrome is CHROME_REDRAW:
+                            w.anchor_reset()
+                            last_render = 0.0
+                            continue
+                        key = chrome or key          # a clicked hint: its key
                     if keys.pressed(key, quit_action):
                         break
                     if on_key is not None:
                         on_key(key)
                         ui.clear_screen()
                         w.anchor_reset()
+                        last_render = 0.0
+                        if hints is not None:
+                            enable_mouse()           # the screen it opened may have turned it off
             else:
                 time.sleep(interval)
     finally:
         if is_tty:
+            if hints is not None:
+                disable_mouse()
             _restore_term_attrs(fd, old_settings)
         sys.stdout.write("\033[?25h\n")
 

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/prompt/keymap.py

@@ -30,13 +30,17 @@ def _row(a: keys.Action) -> Choice:
                          "changed" if changed else ""])
 
 
-def _choices() -> list:
+def _choices(scopes) -> list:
+    """Every action this app has a use for, by its screen: only `scopes`
+    (all, when None), and no transport or volume keys without a player."""
+    from backbone.prompt.chrome import has_owner
     out: list = []
     for scope, title in keys.scopes():
-        if scope == "keys_editor":
-            continue                                 # listed last, below
-        out.append(separator(title))
-        out += [_row(a) for a in keys.actions(scope)]
+        if scope == "keys_editor" or (scopes is not None and scope not in scopes):
+            continue                                 # this page's own are listed last, below
+        rows = [_row(a) for a in keys.actions(scope) if has_owner(a.id)]
+        if rows:
+            out += [separator(title), *rows]
     out.append(separator("This page"))
     out += [_row(a) for a in keys.actions("keys_editor")]
     return out
@@ -102,8 +106,9 @@ def _remove_key(aid: str) -> None:
     ui.show_status(f"{keys.glyph(key)} removed" + ("" if len(bound) > 1 else ": the action has no key now"))
 
 
-def keys_editor() -> None:
-    """The Key bindings page. Returns when backed out of."""
+def keys_editor(scopes: list | None = None) -> None:
+    """The Key bindings page, for the key groups (keys.define scopes) in
+    `scopes`, or every one defined. Returns when backed out of."""
     from backbone.prompt.lists import ListPlace, select
     place = ListPlace()
     while True:
@@ -124,7 +129,7 @@ def keys_editor() -> None:
             hints[keys.label(aid)] = {"remove": "remove a key", "reset": "reset",
                                       "reset_all": "reset all"}[name]
 
-        choice = select("", _choices(), columns=_COLUMNS, place=place,
+        choice = select("", _choices(scopes), columns=_COLUMNS, place=place,
                         header=lambda: rounded_header("Key bindings", "",
                                                       f"{changed} changed" if changed else "all default"),
                         extra_hints={"↵": "add a key"},

backpack_backbone-0.4.0/backbone/prompt/settings.py

@@ -0,0 +1,112 @@
+"""What every back* Settings screen is built from: the two-column row (name,
+then its state), the on/off glyphs and space to flip them, a pick from fixed
+values, and the accent colour picker."""
+from __future__ import annotations
+
+from backbone import ui
+from backbone.prompt.core import Choice, Column, PanelTitle, separator
+from backbone.ui import Colors as C
+
+SETTINGS_COLUMNS = [
+    Column(style='primary'),                 # name, sized to its content
+    Column(style='dynamic-dim', flex=True),  # state, left-aligned just after
+]
+
+# The on/off pair: filled and hollow, not a tick and a cross: ✘ reads as
+# *invalid* rather than *off*. ● and ○ differ only in fill, which is exactly
+# the difference.
+ON_GLYPH, OFF_GLYPH = "●", "○"
+
+
+def state_glyph(value) -> str:
+    """● or ○ for an on/off setting's current state."""
+    return ON_GLYPH if value else OFF_GLYPH
+
+
+def space_toggles(values) -> dict:
+    """select() kwargs making space flip the rows in `values` (the on/off
+    ones): select() returns ("__space__", row), and space does nothing on any
+    other row."""
+    return {"on_inspect": lambda v: ("__space__", v) if v in values else None,
+            "inspect_key": "list.toggle"}
+
+
+def index_of(choices: list, value, default: int = 0) -> int:
+    """Index of the choice whose value == `value` (for putting the cursor back
+    on the row just acted on)."""
+    for i, c in enumerate(choices):
+        if (c.value if isinstance(c, Choice) else c) == value:
+            return i
+    return default
+
+
+def pick_option(question: str, options: dict, current, title: str):
+    """One of a setting's fixed values, `options` being value → label: the
+    one picked, or None when backed out of. The current one is marked."""
+    from backbone.prompt.lists import select
+    return select(question,
+                  choices=[Choice(title=label, value=value, cells=[label, ON_GLYPH if value == current else ""])
+                           for value, label in options.items()],
+                  columns=SETTINGS_COLUMNS, index=index_of(list(options), current),
+                  header=PanelTitle(title))
+
+
+def accent_swatch(value) -> list:
+    """A block of the colour itself, or a hatched gap when there is none."""
+    code = ui.accent_code(value)
+    return [(f"{code}████{C.RESET}", 'normal')] if code else [("░░░░", 'dim')]
+
+
+def accent_name(value, name: str):
+    """The colour's name, written in that colour."""
+    code = ui.accent_code(value)
+    return [(f"{code}{name}{C.RESET}", 'normal')] if code else name
+
+
+ACCENT_COLUMNS = [
+    Column(style='normal'),                  # swatch
+    Column(style='normal'),                  # name, in its own colour
+    Column(style='dynamic-dim', flex=True),  # ● on the one in use
+]
+
+
+def pick_accent(title: str, current, on_pick) -> None:
+    """An accent colour picker: every colour shown in itself, the terminal's
+    own first, then fixed ones and a custom #RRGGBB. Picking one calls
+    `on_pick(value)`, which applies it, so the screen around the list is the
+    preview; it returns when backed out of."""
+    from backbone.prompt.lists import ListPlace, select
+    from backbone.prompt.text import text
+    place = ListPlace()
+    place.value = '__custom__' if str(current).startswith('#') else current
+    while True:
+        custom = current if str(current).startswith('#') else None
+
+        def _row(value, name: str, colour) -> Choice:
+            in_use = value == current or (value == '__custom__' and custom)
+            return Choice(title=name, value=value,
+                          cells=[accent_swatch(colour), accent_name(colour, name), ON_GLYPH if in_use else ""])
+
+        choices: list = [separator("Your terminal's colours")]
+        for i, (key, name, _colour) in enumerate(ui.ACCENT_PRESETS):
+            if i == 6:
+                choices.append(separator("Fixed colours"))
+            choices.append(_row(key, name, key))
+        choices += [separator(), _row('__custom__', 'Custom colour…', custom)]
+
+        choice = select("", choices=choices, columns=ACCENT_COLUMNS, place=place,
+                        header=PanelTitle(title, ui.accent_label(current)))
+        if not choice:
+            return
+        if choice == '__custom__':
+            typed = text("Hex colour:", default=custom or "", placeholder="#4FC3F7")
+            if typed is None:
+                continue
+            rgb = ui.parse_hex_colour(typed)
+            if rgb is None:
+                ui.show_status("That isn't a colour. Use #RRGGBB, like #4FC3F7.")
+                continue
+            choice = "#%02X%02X%02X" % rgb
+        current = choice
+        on_pick(choice)
+        ui.show_status(f"{title}: {ui.accent_label(choice)}")

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backbone/ui.py

@@ -103,8 +103,7 @@ MARGIN_V = 1   # rows reserved on each vertical side (top and bottom)
 FOOTER_GLYPH_COLS = ((0, 2), (4, 2))
 
 class Colors:
-    """The named palette every widget uses, plus semantic colours for a tool's
-    own views (FRAME, TEAL, AMBER, RED, TXT, MUTE) and the short aliases R and B.
+    """The named palette every widget uses, and RED for what failed.
     All empty when colour is off (NO_COLOR, or set_colour(False))."""
     PRIMARY = "\033[1;37m" # Bold white
     WHITE = "\033[37m" # Normal white
@@ -127,23 +126,14 @@ class Colors:
     BAR_DIM = "\033[48;5;235m"
     HIDE = "\033[?25l"
     SHOW = "\033[?25h"
-    # semantic colours for a tool's own views (backcrack's watch uses RED for failures)
-    FRAME = "\033[38;5;239m"
-    TEAL = "\033[38;5;43m"
-    AMBER = "\033[38;5;179m"
-    RED = "\033[38;5;167m"
-    TXT = "\033[38;5;252m"
-    MUTE = "\033[38;5;243m"
-    R = RESET            # short aliases
-    B = BOLD
+    RED = "\033[38;5;167m"   # a failure: a text field's problem, backcrack's FAIL lines
 
 
 # The styling half of Colors: everything that paints rather than moves the
 # cursor. Suppressing colour must not suppress HIDE/SHOW, which are cursor
 # control and still needed on a pipe.
 _STYLE_NAMES = ('PRIMARY', 'WHITE', 'ACCENT', 'ACCENT2', 'CYAN', 'YELLOW', 'MAGENTA', 'GREEN',
-                'DIM', 'BOLD', 'ITALIC', 'UNDERLINE', 'RESET', 'BACK', 'INVERT', 'BAR', 'BAR_DIM',
-                'FRAME', 'TEAL', 'AMBER', 'RED', 'TXT', 'MUTE', 'R', 'B')
+                'DIM', 'BOLD', 'ITALIC', 'UNDERLINE', 'RESET', 'BACK', 'INVERT', 'BAR', 'BAR_DIM', 'RED')
 _STYLE_CODES = {name: getattr(Colors, name) for name in _STYLE_NAMES}
 
 
@@ -1084,43 +1074,39 @@ def _get_breadcrumb_str(width: int) -> str:
 
 
 
-def get_progress_bar(progress: float, width: int = 40, span: tuple | None = None) -> str:
-    """
-    A pip-style progress bar.
-    [━━━━━━━━━━━━━━━━━━━━━━━━╸          ]
-    `span`: a section to pick out (see progress_cells).
-    """
-    return f"{Colors.DIM}[{Colors.RESET}{progress_cells(progress, width, span)}{Colors.DIM}]{Colors.RESET}"
+def progress_caps(caps: bool) -> tuple[str, str]:
+    """A progress bar's end caps: brackets on a bare bar, none on one in a box
+    (the box already frames it)."""
+    return ("[", "]") if caps else ("", "")
 
 
-def progress_cells(progress: float, width: int, span: tuple | None = None, rest: str = " ") -> str:
-    """A progress bar's `width` cells, coloured: what's played bright, the rest
-    `rest` (dim). `span`: (start, end) fractions of one section (a chapter) to
-    pick out: from its start to now in the accent colour, from now to its end dim."""
-    progress = max(0, min(1, progress))
+def progress_caps_width(caps: bool) -> int:
+    """Columns the caps add around a progress bar's cells."""
+    return sum(map(len, progress_caps(caps)))
 
-    filled_width = progress * width
-    whole_blocks = int(filled_width)
-    remainder = filled_width - whole_blocks
 
-    bar = "━" * whole_blocks
+def get_progress_bar(progress: float, width: int = 40, span: tuple | None = None, caps: bool = True) -> str:
+    """
+    A pip-style progress bar.
+    [━━━━━━━━━━━━━━━━━━━━━━━━━──────────]
+    `span`: a section to pick out (see progress_cells). `caps`: see progress_caps.
+    """
+    left, right = progress_caps(caps)
+    return f"{Colors.DIM}{left}{Colors.RESET}{progress_cells(progress, width, span)}{Colors.DIM}{right}{Colors.RESET}"
 
-    # half-cell tip
-    if whole_blocks < width:
-        if remainder > 0.6:
-            bar += "━" # Almost full
-        elif remainder > 0.2:
-            bar += "╸" # Partial tip
-        else:
-            bar += " " # Not enough for a tip yet
 
-    cells = [(Colors.PRIMARY, c) for c in bar.rstrip(" ")]
-    cells += [(Colors.DIM, rest)] * (width - len(cells))
+def progress_cells(progress: float, width: int, span: tuple | None = None) -> str:
+    """A progress bar's `width` cells: what's played heavy and bright, whole
+    cells only, the rest thin and dim. `span`: (start, end) fractions of one
+    section (a chapter) to pick out: from its start to now in the accent
+    colour, from now to its end dim."""
+    played = round(max(0, min(1, progress)) * width)
+    cells = [(Colors.PRIMARY, "━")] * played + [(Colors.DIM, "─")] * (width - played)
     if span:
         lo = max(0, min(width - 1, int(span[0] * width)))
         hi = max(lo + 1, min(width, round(span[1] * width)))
-        cells[lo:hi] = [(Colors.ACCENT, c) if colour == Colors.PRIMARY else (Colors.DIM, "━")
-                        for colour, c in cells[lo:hi]]
+        cells[lo:hi] = [(Colors.ACCENT, c) if i < played else (Colors.DIM, "━")
+                        for i, (_, c) in enumerate(cells[lo:hi], lo)]
     return "".join(f"{colour}{''.join(c for _, c in group)}{Colors.RESET}"
                    for colour, group in groupby(cells, key=lambda cell: cell[0]))
 
@@ -1132,8 +1118,6 @@ C = Colors   # the short name every widget uses
 
 SPIN = list("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
 
-PARTS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]   # eighth-block fill steps
-
 SPARK = "▁▂▃▄▅▆▇█"
 
 def content_width(min_width: int = 1) -> int:
@@ -1144,21 +1128,6 @@ def content_width(min_width: int = 1) -> int:
     """
     return max(min_width, get_terminal_width() - 2 * MARGIN_H)
 
-def rule(n: int) -> str:
-    return "─" * n
-
-def bar(pct: int, width: int, color: str = "") -> str:
-    color = color or Colors.TEAL
-    pct = max(0, min(100, pct))
-    eighths = pct * width * 8 // 100
-    full, rem = divmod(eighths, 8)
-    out = color + "█" * full
-    if rem and full < width:
-        out += PARTS[rem]
-        full += 1
-    out += Colors.MUTE + "─" * (width - full) + Colors.R
-    return out
-
 def rate_of_change(history: list, now: float, value: float, window: float = 20.0, max_len: int = 60):
     """Tracks `value` over time in `history` (a list of (ts, value) pairs,
     mutated in place and capped to `max_len` entries) and returns its rate
@@ -1193,68 +1162,6 @@ def sparkline(rate_history: list, rate: float, max_len: int = 14) -> str:
     mx = max(rate_history, default=1) or 1
     return "".join(SPARK[max(0, min(7, int(r / mx * 7.99)))] for r in rate_history)
 
-def header_box(left: str, right: str, cols: int, spin: str = "") -> list:
-    """The 3-line rounded header frame (top rule, title row, bottom rule)
-    for a live view - `cols` is total frame width, i.e. content_width()'s
-    return value. The title row's padding is computed from the *actual*
-    rendered pieces (left, right, spin), so the right border always lands
-    exactly under the corners no matter how any of the three are sized -
-    this single spot is the only place that math needs to be right.
-
-    Truncates `left` (then `right`, if even that isn't enough) so the row
-    never runs past `cols` regardless of terminal width - `right` (typically
-    a short, fixed-format clock) is kept whole for as long as it can be;
-    `left` (the variable, more compressible piece - a title/library name)
-    gives way first.
-
-    Bakes in its own MARGIN_H left indent (matching every hand-written
-    widget line in backbone/prompt/ - e.g. confirm()'s
-    f"  {message}") rather than relying on a wrapper to add it: a caller
-    driving its view through _Widget.render() (prompt/core.py) gets no
-    such wrapper, since _Widget only manages the vertical margin itself.
-    """
-    interior = cols - 2
-    # Reserve the spinner plus one pad column *before* sizing left/right, so
-    # truncating to fit `budget` always leaves room for pad >= 1 - flooring
-    # pad afterward instead (max(1, ...)) can push the row a column past the
-    # border once left+right already exactly fill the interior.
-    budget = max(0, interior - len(spin) - 1)
-    if visual_len(left) + visual_len(right) > budget:
-        right = truncate_text(right, min(visual_len(right), budget))
-        left = truncate_text(left, max(0, budget - visual_len(right)))
-    pad = max(0, interior - visual_len(left) - visual_len(right) - len(spin))
-    C = Colors
-    hpad = " " * MARGIN_H
-    return [
-        f"{hpad}{C.FRAME}╭{rule(interior)}╮{C.R}",
-        f"{hpad}{C.FRAME}│{C.B}{left}{C.R}{' ' * pad}{C.TXT}{right}{C.R}{spin}{C.FRAME}│{C.R}",
-        f"{hpad}{C.FRAME}╰{rule(interior)}╯{C.R}",
-    ]
-
-def wrap_margins(lines: list, width: int = None) -> str:
-    """Applies the global MARGIN_H/MARGIN_V inset plus per-line
-    clear-to-end-of-line, ready for one `sys.stdout.write` - the standard
-    back* frame render (pair with an `ESC[H` cursor-home beforehand).
-
-    Joins with \\r\\n, not \\n: raw terminal mode (tty.setraw, used by
-    backbone.prompt.core for key reading) clears OPOST, so the terminal
-    stops translating a bare \\n into a carriage return - every line after
-    the first would otherwise start wherever the previous one ended instead
-    of column 1.
-
-    `width` (typically content_width()'s return value), if given, clips
-    every line to it first - a safety net so one field a caller forgot to
-    size itself can't overflow the whole frame. Hand-tuned per-field
-    truncation still reads better (an ellipsis where it makes sense, not a
-    hard cut mid-word); this is the guarantee behind it, not a replacement.
-    """
-    if width is not None:
-        lines = [clip_ansi(line, width) for line in lines]
-    hpad = " " * MARGIN_H
-    vpad = ["\033[K"] * MARGIN_V
-    out = vpad + [hpad + line + "\033[K" for line in lines] + vpad
-    return "\r\n".join(out)
-
 def spinner(frame: int) -> str:
     return SPIN[frame % len(SPIN)]
 
@@ -1280,33 +1187,13 @@ _ANSI_DEMO = re.compile(r"\033\[[0-9;]*[a-zA-Z]")
 
 
 def _demo() -> None:
-    """Self-check for the pure logic here, header_box's alignment above all.
+    """Self-check for the pure logic here.
     Runs without a terminal: `python3 -m backbone.ui`.
     """
-    for cols in (70, 100, 137):
-        for left, right, spin in (("  SHORT", "12:00:00  ", "X"), ("", "", ""), ("a" * 20, "b", "Y")):
-            top, mid, bot = header_box(left, right, cols, spin)
-            widths = {len(strip_ansi(top)), len(strip_ansi(mid)), len(strip_ansi(bot))}
-            assert len(widths) == 1, (cols, left, right, spin, widths)
-    # A left piece far longer than the frame must truncate, not overflow -
-    # the border still lines up at a width too narrow for it whole.
-    for cols in (10, 20, 40):
-        top, mid, bot = header_box("a" * 200, "12:00:00  ", cols, "X")
-        widths = {len(strip_ansi(top)), len(strip_ansi(mid)), len(strip_ansi(bot))}
-        assert len(widths) == 1, (cols, widths)
-        assert len(strip_ansi(mid)) == cols + MARGIN_H, (cols, len(strip_ansi(mid)))
     assert visual_len("plain") == 5
     assert visual_len(f"{Colors.BOLD}x{Colors.RESET}") == 1
     assert truncate_text("abcdefgh", 4) == "abc…"
     assert plural(1, "disc") == "1 disc" and plural(2, "disc") == "2 discs"
-    # Regression guard: wrap_margins must join with \r\n, not \n - under raw
-    # terminal mode (OPOST cleared) a bare \n never returns to column 1, and
-    # every line after the first starts wherever the previous one ended.
-    assert "\r\n" in wrap_margins(["a", "b"])
-    # wrap_margins(width=...) must clip an oversized line rather than let it
-    # overflow - the safety net behind every tool's own per-field sizing.
-    clipped = wrap_margins(["a" * 200], width=10).split("\r\n")[1]
-    assert len(strip_ansi(clipped)) <= 10 + MARGIN_H, clipped
     assert human_gb(1048576) == "1.0"
     hist = []
     assert rate_of_change(hist, 0.0, 0) is None            # first sample - no window yet

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0/backpack_backbone.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backpack-backbone
-Version: 0.3.1
+Version: 0.4.0
 Summary: Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once.
 License: MIT
 Project-URL: Homepage, https://github.com/RedEraRrow/backbone
@@ -50,9 +50,9 @@ how to install anything it can't run without.
 ## What's in it
 
 **`ui`** - the visual layer. `Colors` (honours `NO_COLOR=1`), the global
-`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, `wrap_margins`,
-`rule`, `bar`, `header_box`, `sparkline`, `spinner`, `rate_of_change`, and
-the `SPIN` / `PARTS` / `SPARK` glyph sets. Also the ANSI-aware text
+`MARGIN_H` / `MARGIN_V` inset every frame is drawn inside, the progress
+bar (`progress_cells`, `get_progress_bar`), `sparkline`, `spinner`,
+`rate_of_change`, and the `SPIN` / `SPARK` glyph sets. Also the ANSI-aware text
 measuring (`visual_len`, `truncate_text`, `clip_ansi`, `strip_ansi`) that
 makes any of that survive colour codes and wide characters, and small
 formatters: `plural`, `human_gb`, `dir_size_kb`. The accent colour is chosen
@@ -61,8 +61,8 @@ at startup from its own settings, and `accent_code` / `accent_label` let a
 settings screen check and name a value.
 
 `from backbone import ...` exposes only a subset of `ui` (`Colors`, the
-margins and glyph sets, `spinner`, `content_width`, `rule`, `bar`,
-`header_box`, `wrap_margins`); import anything else from its module, e.g.
+margins and glyph sets, `spinner`, `content_width`); import anything else
+from its module, e.g.
 `from backbone.ui import human_gb`.
 
 **`prompt`** - the widgets. `select` (single or multi), `confirm`, `text`,
@@ -72,6 +72,13 @@ values: `calendar_select`, `datetime_edit`, `time_edit`,
 `system_editor_edit`. All resize-aware, all mouse-aware, all rendered through
 the same painter.
 
+**`prompt.settings`** - what a Settings screen is built from, so every
+tool's reads the same: `SETTINGS_COLUMNS` (a name, then its state),
+`state_glyph` (● / ○), `space_toggles` (space flips the on/off rows),
+`index_of` (the cursor back on the row just changed), `pick_option` (one of
+a fixed set of values) and `pick_accent` (the accent colour picker, each
+colour shown in itself).
+
 **`prompt.core`** - the primitives underneath: the screen-diff painter, key
 reading, the `Choice` and `Column` types, the footer hint bar (`hint`) and its
 click mapping, and `run_dashboard`.
@@ -122,12 +129,16 @@ family (for typo scoring); raw key reads and escape decoding.
 through the same `_Widget` machinery every prompt widget uses, rather than each
 tool hand-rolling a redraw loop:
 
-    from backbone.prompt.core import run_dashboard
+    from backbone.prompt.chrome import chrome_room
+    from backbone.prompt.core import box_lines, run_dashboard
+    from backbone.ui import content_width
+
+    HINTS = [("q", "quit")]
 
     def render() -> list:
-        return ["  line one", "  line two"]
+        return box_lines(["line one", "line two"], content_width(), 4, "Status")
 
-    run_dashboard(render, interval=1.0, quit_key="q")
+    run_dashboard(render, interval=1.0, quit_action="list.quit", hints=HINTS)
 
 `render()` returns the whole frame as a list of lines, each carrying its own
 left indent, and only runs once per `interval`. Keypresses and resizes are
@@ -136,6 +147,10 @@ instead of waiting out the data-refresh cadence. `on_key` handles anything
 other than the quit key and is free to open a `select()` or `confirm()` of its
 own; the dashboard repaints from scratch when it returns.
 
+With `hints`, the hint bar goes under the frame as every other screen's does,
+with the help toggle and clickable keys; `chrome_room(hints)` is the rows the
+frame has above it. A window too small for boxes gets backbone's own notice.
+
 When stdin isn't a terminal (run from a script, or with input redirected),
 it falls back to a plain sleep loop and never reads keys, so such a view has
 to be stopped from outside.

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/backpack_backbone.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ backbone/prompt/dates.py
 backbone/prompt/keymap.py
 backbone/prompt/list_edit.py
 backbone/prompt/lists.py
+backbone/prompt/settings.py
 backbone/prompt/text.py
 backbone/prompt/timezone.py
 backbone/prompt/values.py

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "backpack-backbone"
-version = "0.3.1"
+version = "0.4.0"
 description = "Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once."
 requires-python = ">=3.10"
 readme = "README.md"

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/tests/test_boxes.py

@@ -1,5 +1,6 @@
 """Boxed panels: the box itself, and select() drawing its list inside one."""
 import io
+import time
 import re
 import sys
 import unittest
@@ -405,6 +406,25 @@ class FloatTest(unittest.TestCase):
         self.assertTrue(out.getvalue().startswith("\r"))
         self.assertFalse(core._float)
 
+    def test_a_pulse_takes_it_away_on_time_too(self):
+        """With music playing, state-change pulses come faster than the idle
+        tick: each one must do the tick's work, or the box never goes."""
+        import os as _os
+        out = io.StringIO()
+        with patch.object(sys, 'stdout', out):
+            core.screen_float(["[ VOL ]"], 60)
+        core._float['until'] = 0                                            # its time is up
+        r, w = _os.pipe()
+        _os.write(w, b"x")
+        try:
+            with patch.object(core, '_wake_r', r), patch.object(core, '_footer_last_draw', [time.time()]), \
+                 patch.object(core, '_render_footer_bar', lambda: None), \
+                 patch.object(core._sel, 'select', lambda *a: ([r], [], [])), patch.object(sys, 'stdout', out):
+                core._wait_for_keypress(0)
+        finally:
+            _os.close(r); _os.close(w)
+        self.assertFalse(core._float)                                       # gone, though no idle tick was due
+
     def test_rows_painted_under_it_leave_it_be_and_come_back_after(self):
         row = "x" * 40
         core.screen_row_paint(5, row)

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/tests/test_keys.py

@@ -86,5 +86,53 @@ class KeysTest(unittest.TestCase):
         self.assertTrue(keys.bindable("n"))
 
 
+
+class VolumeKeysTest(unittest.TestCase):
+    """+ and - turn the volume on any screen that leaves them free, never in
+    a text field (where they're typed)."""
+
+    def test_free_screens_turn_it_typing_ones_do_not(self):
+        from backbone.prompt import chrome
+        got = []
+        was = chrome._transport_handler
+        chrome.set_transport_handler(got.append)
+        try:
+            self.assertIs(chrome.consume_chrome("+", {}, free_keys=True), chrome.CHROME_HANDLED)
+            self.assertIs(chrome.consume_chrome("-", {}, free_keys=True), chrome.CHROME_HANDLED)
+            self.assertIsNone(chrome.consume_chrome("+", {}))              # typed here: not ours
+        finally:
+            chrome.set_transport_handler(was)
+        self.assertEqual(got, ["vol_up", "vol_down"])
+
+
+class KeyBindingsPageTest(unittest.TestCase):
+    """The Key bindings page lists what the app has a use for: the screens it
+    names, and the transport and volume keys only with a player."""
+
+    def rows(self, scopes=None, handler=None, opener=None):
+        from backbone.prompt import chrome, keymap
+        with patch.object(chrome, "_transport_handler", handler), patch.object(chrome, "_player_opener", opener):
+            return [c.value or c.title for c in keymap._choices(scopes)]
+
+    def test_no_player_no_transport_keys(self):
+        rows = self.rows()
+        self.assertNotIn("global.playpause", rows)
+        self.assertNotIn("global.player", rows)
+        self.assertNotIn("Volume", rows)                  # its group goes with its keys
+        self.assertIn("global.help", rows)
+
+    def test_with_a_player_they_are_there(self):
+        rows = self.rows(handler=print, opener=print)
+        self.assertIn("global.playpause", rows)
+        self.assertIn("global.player", rows)
+        self.assertIn("volume.up", rows)
+
+    def test_only_the_named_groups(self):
+        rows = self.rows(["list"])
+        self.assertIn("list.up", rows)
+        self.assertNotIn("confirm.yes", rows)
+        self.assertEqual(rows[-4:], ["This page", "keys_editor.remove", "keys_editor.reset", "keys_editor.reset_all"])
+
+
 if __name__ == "__main__":
     unittest.main()

{backpack_backbone-0.3.1 → backpack_backbone-0.4.0}/tests/test_ui_progress.py

@@ -64,14 +64,21 @@ if __name__ == "__main__":
 class ProgressBarSpanTest(unittest.TestCase):
     def test_span_is_accent_up_to_now_then_dim(self):
         bar = ui.get_progress_bar(0.5, 20, (0.4, 0.7))
-        self.assertEqual(ui.strip_ansi(bar), "[" + "━" * 14 + " " * 6 + "]")
+        self.assertEqual(ui.strip_ansi(bar), "[" + "━" * 14 + "─" * 6 + "]")
         self.assertIn(f"{ui.Colors.ACCENT}━━{ui.Colors.RESET}", bar)       # cells 8-9: played
-        self.assertIn(f"{ui.Colors.DIM}━━━━ ", bar)                         # cells 10-13: to come, then empty
+        self.assertIn(f"{ui.Colors.DIM}━━━━──", bar)                        # cells 10-13: to come, then the rest
 
     def test_cells_alone_take_a_rest_glyph(self):
-        cells = ui.strip_ansi(ui.progress_cells(0.5, 10, (0.3, 0.8), rest="─"))
+        cells = ui.strip_ansi(ui.progress_cells(0.5, 10, (0.3, 0.8)))
         self.assertEqual(cells, "━" * 8 + "──")
 
+    def test_whole_cells_only(self):
+        self.assertEqual(ui.strip_ansi(ui.progress_cells(0.44, 10)), "━━━━──────")
+        self.assertEqual(ui.strip_ansi(ui.progress_cells(0.46, 10)), "━━━━━─────")
+
+    def test_a_boxed_bar_drops_its_caps(self):
+        self.assertEqual(ui.strip_ansi(ui.get_progress_bar(0.5, 4, caps=False)), "━━──")
+
     def test_no_span_is_unchanged(self):
         self.assertNotIn(ui.Colors.ACCENT, ui.get_progress_bar(0.5, 20))