The Courier outbox is a TARGET and TRIGGER table, and Enter opens the message
Each section of the outbox now has column headers: TARGET and TRIGGER for waiting entries, TARGET and OUTCOME for finished ones. The rows no longer show the message. Enter on a waiting entry opens it to edit (the courier holds the entry while the prompt is open, so the old text cannot go out meanwhile), and Enter on a finished one shows it. Del deletes an entry after a red confirm, and ^R sends a waiting entry now; on the PicoCalc they ride F3 as Send, with Delete behind it. On a narrow screen a long name gives cells to the trigger and breaks off on its crack. The message field has the colours of the chat's compose line: a white prompt mark and white text. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
1b30f353c6
commit
0b931e7cc4
8 files changed
+744
-165
No files matched your search
@@ -235,6 +235,40 @@ class CourierStore:
|
||||
self._save()
|
||||
return True
|
||||
|
||||
def edit(self, ident: int, text: str) -> bool:
|
||||
"""Replace the body of a waiting entry. Its schedule and its attempts stay.
|
||||
|
||||
A finished entry is history: its body is what went out (or what MeshTerm stopped
|
||||
trying to send), so it does not change.
|
||||
|
||||
Returns:
|
||||
Whether a waiting entry got the new body.
|
||||
"""
|
||||
message = self.get(ident)
|
||||
if message is None or message.status != QUEUED:
|
||||
return False
|
||||
if message.text != text:
|
||||
message.text = text
|
||||
self._save()
|
||||
return True
|
||||
|
||||
def delete(self, ident: int) -> bool:
|
||||
"""Remove one entry, waiting or finished.
|
||||
|
||||
For a waiting entry, this is the same as :meth:`cancel`. The outbox screen deletes
|
||||
one row of either section with the Delete key.
|
||||
|
||||
Returns:
|
||||
Whether an entry was removed.
|
||||
"""
|
||||
messages = self._load()
|
||||
kept = [m for m in messages if m.ident != ident]
|
||||
if len(kept) == len(messages):
|
||||
return False
|
||||
self._messages = kept
|
||||
self._save()
|
||||
return True
|
||||
|
||||
def clear_done(self) -> None:
|
||||
"""Remove all the finished entries, and do not change the waiting queue."""
|
||||
messages = self._load()
|
||||
|
||||
@@ -29,6 +29,8 @@ the header comes on when a delivery during the night is at last complete.
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from collections.abc import Iterator
|
||||
from contextlib import contextmanager
|
||||
from datetime import datetime
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
@@ -81,8 +83,11 @@ class CourierService:
|
||||
#: The time when MeshTerm last heard each node id in this session (the freshness
|
||||
#: map).
|
||||
self._heard: dict[str, datetime] = {}
|
||||
#: Re-entry guard: only one try at a time is in progress, from a pass or forced.
|
||||
self._sending = False
|
||||
#: Re-entry guard: only one try at a time is in progress, from a pass or forced. It
|
||||
#: is the id of the entry that the try sends, or ``None`` when no try runs.
|
||||
self._in_flight: int | None = None
|
||||
#: The ids of the entries that the user edits now. A pass does not try them.
|
||||
self._held: set[int] = set()
|
||||
|
||||
@property
|
||||
def active(self) -> bool:
|
||||
@@ -93,6 +98,24 @@ class CourierService:
|
||||
"""How many messages wait in the outbox."""
|
||||
return self._ctx.courier_store.pending_count()
|
||||
|
||||
def in_flight(self, ident: int) -> bool:
|
||||
"""Whether a delivery try of the entry ``ident`` is in progress now."""
|
||||
return self._in_flight == ident
|
||||
|
||||
@contextmanager
|
||||
def holding(self, ident: int) -> Iterator[None]:
|
||||
"""Keep the passes off one entry while the user edits its body.
|
||||
|
||||
Without the hold, a pass can send the old body while the edit prompt is open. Then
|
||||
the edit changes the text of a message that already went out. A forced try
|
||||
(:meth:`attempt_now`) does not read the hold, because the user asks for it.
|
||||
"""
|
||||
self._held.add(ident)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
self._held.discard(ident)
|
||||
|
||||
# --- lifecycle ---------------------------------------------------------------------
|
||||
|
||||
async def start(self) -> None:
|
||||
@@ -191,11 +214,11 @@ class CourierService:
|
||||
|
||||
async def _pass(self) -> None:
|
||||
"""One pass: try the oldest eligible entry, if there is one (one for each pass)."""
|
||||
if not self._ctx.is_connected or self._sending:
|
||||
if not self._ctx.is_connected or self._in_flight is not None:
|
||||
return
|
||||
now = utcnow()
|
||||
for message in self._ctx.courier_store.pending():
|
||||
if self.eligible(message, now):
|
||||
if message.ident not in self._held and self.eligible(message, now):
|
||||
await self._attempt(message)
|
||||
return
|
||||
|
||||
@@ -212,14 +235,14 @@ class CourierService:
|
||||
message = self._ctx.courier_store.get(ident)
|
||||
if message is None or message.status != QUEUED:
|
||||
return "gone"
|
||||
if self._sending:
|
||||
if self._in_flight is not None:
|
||||
return "busy"
|
||||
return await self._attempt(message)
|
||||
|
||||
async def _attempt(self, message: QueuedMessage) -> str:
|
||||
"""Run one delivery try, and set the new state of the entry."""
|
||||
store = self._ctx.courier_store
|
||||
self._sending = True
|
||||
self._in_flight = message.ident
|
||||
try:
|
||||
contact = await self._resolve(message)
|
||||
if contact is None:
|
||||
@@ -258,7 +281,7 @@ class CourierService:
|
||||
)
|
||||
return "no ack"
|
||||
finally:
|
||||
self._sending = False
|
||||
self._in_flight = None
|
||||
|
||||
def _delivered_late(self, ident: int) -> None:
|
||||
"""The ack of a try arrived after the try stopped its wait: the message was delivered.
|
||||
|
||||
@@ -17,8 +17,8 @@ On the CLI, subcommands give script access to the same outbox:
|
||||
- ``send`` forces one delivery try now.
|
||||
- ``list``, ``cancel``, and ``clear`` examine the outbox and remove entries from it.
|
||||
|
||||
These subcommands are the script form of the Send-now, Cancel, and Clear-finished actions
|
||||
of the outbox screen.
|
||||
These subcommands are the script form of the actions of the outbox screen: Send now
|
||||
(``^R``), Delete (``cancel`` deletes only a waiting entry), and Clear finished.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
+340
-117
@@ -4,13 +4,16 @@
|
||||
The interactive face of the ``courier`` tool. One select-list screen holds the whole
|
||||
feature (the persistent-backdrop pattern). It has these parts:
|
||||
|
||||
- The waiting outbox. Each entry shows its live state: it waits to hear the contact, it is
|
||||
scheduled for a time, or it backs off between retries.
|
||||
- The finished history (delivered or given up).
|
||||
- The waiting outbox. Each row shows its target (the recipient) and its trigger: what the
|
||||
entry waits for before it goes out. It waits to hear the contact, it is scheduled for a
|
||||
time, or it backs off between retries.
|
||||
- The finished history (delivered or given up), with the outcome of each entry.
|
||||
- The queueing flow: select a contact, write the message, choose when to send it.
|
||||
|
||||
Enter on a waiting entry offers *Send now* (one forced attempt, and the outcome is in a
|
||||
dialog) and *Cancel*.
|
||||
A row does not show its message. Enter on a waiting entry opens the message to edit, and
|
||||
Enter on a finished entry opens it to read. ``^R`` on a waiting entry is *Send now* (one
|
||||
forced attempt, and the outcome is in a dialog). Delete removes an entry of either section,
|
||||
after a confirm.
|
||||
|
||||
The outbox is **live** while it is open. Each row is a callable title that the code
|
||||
computes again at each paint, so "retry in ~N m" counts down in real time. A ticker
|
||||
@@ -37,9 +40,16 @@ from rich.text import Text
|
||||
from ..core.courier_store import DELIVERED, QUEUED, QueuedMessage
|
||||
from ..core.models import Contact, is_direct_messageable, utcnow
|
||||
from .contactlist import SORT_COLUMNS, SORT_OPENS_ASCENDING, ContactListScreen, ContactRow
|
||||
from .menus import icon_lane, marked_label, run_steps, section_heading
|
||||
from .pathline import PathHop
|
||||
from .tui import CANCEL, DM_BYTE_LIMIT, Choice, SelectScreen, Separator
|
||||
from .menus import (
|
||||
Lane,
|
||||
column_header,
|
||||
icon_lane,
|
||||
marked_label,
|
||||
run_steps,
|
||||
section_heading,
|
||||
)
|
||||
from .pathline import PathHop, cut_to
|
||||
from .tui import CANCEL, DM_BYTE_LIMIT, Choice, DeleteRequest, SelectScreen, Separator
|
||||
from .watchtower_screen import contact_watch_key
|
||||
from .widgets import (
|
||||
DESTINATION,
|
||||
@@ -58,6 +68,9 @@ if TYPE_CHECKING:
|
||||
_QUEUE = ("queue",)
|
||||
_CLEAR = ("clear",)
|
||||
|
||||
#: The first item of the value with which ``^R`` resolves the outbox: ``("send", ident)``.
|
||||
_SEND = "send"
|
||||
|
||||
#: The status marks that an outbox entry starts with: waiting, delivered, gave up. They are
|
||||
#: the outcome of the row and not decoration. Thus, unlike the icon of a command row, they
|
||||
#: are drawn on each platform. The code measures them raw, because the render fold of the
|
||||
@@ -75,14 +88,23 @@ _COMMAND_ICONS = ("📨", "🗑")
|
||||
#: The seconds between the refresh ticks of the open outbox (shape check and paint).
|
||||
_REFRESH_S = 1.0
|
||||
|
||||
#: The maximum width at which a message body renders in a row, before the row gets an
|
||||
#: ellipsis.
|
||||
_TEXT_W = 36
|
||||
#: The cells between the TARGET lane and the lane after it.
|
||||
_GAP = 2
|
||||
|
||||
#: The fewest cells that the last lane (TRIGGER or OUTCOME) keeps on a narrow screen. A
|
||||
#: long name gives cells back first, because the first letters of a chip already show who
|
||||
#: it is, and the trigger is what the user opens the outbox to read.
|
||||
_LAST_MIN = 20
|
||||
|
||||
def _shorten(text: str, width: int = _TEXT_W) -> str:
|
||||
"""The message body, shortened for the display in a row."""
|
||||
return text if len(text) <= width else text[: width - 1] + "…"
|
||||
#: How many finished entries the history section shows. The store keeps more (refer to the
|
||||
#: ``courier_history_kept`` preference).
|
||||
_DONE_SHOWN = 15
|
||||
|
||||
#: The footer of the outbox. :meth:`CourierOutboxScreen._key_atoms` adds the atoms of the
|
||||
#: keys that act on an entry, only while the highlight is on such an entry.
|
||||
_OUTBOX_HINT = "↑↓ move · type to filter · Enter open · Esc back"
|
||||
_SEND_HINT = "^R send"
|
||||
_DELETE_HINT = "Del delete"
|
||||
|
||||
|
||||
def _local_stamp(when: datetime) -> str:
|
||||
@@ -150,7 +172,7 @@ async def open_courier(ctx: AppContext) -> dict[str, Any] | None:
|
||||
# how to compose its sections again around the highlight
|
||||
# (:meth:`CourierOutboxScreen.refresh`). The ticker calls this method once each second
|
||||
# while the list is open. The code runs the screen through a visit. Thus each sub-flow
|
||||
# (queue a message, the actions of an entry, the clear confirm) floats over the list and
|
||||
# (queue a message, the message of an entry, a send, a confirm) floats over the list and
|
||||
# returns to the row from which it opened. Also, the code starts the ticker one time,
|
||||
# and not for each round.
|
||||
menu = CourierOutboxScreen(ctx)
|
||||
@@ -182,8 +204,12 @@ async def open_courier(ctx: AppContext) -> dict[str, Any] | None:
|
||||
destructive=True,
|
||||
):
|
||||
store.clear_done()
|
||||
elif isinstance(choice, DeleteRequest):
|
||||
await _delete_entry(ctx, int(choice.value[1]))
|
||||
elif isinstance(choice, tuple) and choice[0] == _SEND:
|
||||
await _send_now(ctx, int(choice[1]))
|
||||
elif isinstance(choice, tuple) and choice[0] == "msg":
|
||||
await _entry_actions(ctx, int(choice[1]))
|
||||
await _open_entry(ctx, int(choice[1]))
|
||||
# Take in the effect of the flow at once, and do not wait for a tick. Thus
|
||||
# the list to which the user returns already shows what the user did.
|
||||
menu.refresh()
|
||||
@@ -212,6 +238,11 @@ class CourierOutboxScreen(SelectScreen):
|
||||
store. It composes the sections again in place only when the fingerprint changed, and
|
||||
the highlight stays on its entry (the rebuild idiom of
|
||||
:class:`~meshterm.ui.contactlist.ContactListScreen`).
|
||||
|
||||
Three keys act on the highlighted entry. Enter opens its message (refer to
|
||||
:func:`_open_entry`), Delete asks to remove it, and ``^R`` sends a waiting entry now.
|
||||
The footer and the F-key lane name ``^R`` and Delete only on the rows on which they act.
|
||||
``^R`` is a chord, because this list filters as the user types.
|
||||
"""
|
||||
|
||||
def __init__(self, ctx: AppContext, *, default: Any = None) -> None:
|
||||
@@ -226,9 +257,69 @@ class CourierOutboxScreen(SelectScreen):
|
||||
"Courier — store-and-forward outbox",
|
||||
_menu_items(ctx, ctx.courier_store.entries()),
|
||||
default=default,
|
||||
footer_hint="↑↓ move · Enter select · Esc back",
|
||||
footer_hint=_OUTBOX_HINT,
|
||||
key_hint=self._key_atoms,
|
||||
)
|
||||
|
||||
def _waiting(self, value: Any) -> int | None:
|
||||
"""The id of the entry that ``value`` names, if that entry waits in the outbox."""
|
||||
ident = _entry_ident(value)
|
||||
if ident is None:
|
||||
return None
|
||||
message = self._ctx.courier_store.get(ident)
|
||||
return ident if message is not None and message.status == QUEUED else None
|
||||
|
||||
def _highlighted_waiting(self) -> int | None:
|
||||
"""The id of the highlighted entry, if it waits in the outbox."""
|
||||
current = self._current_choice()
|
||||
return self._waiting(current.value) if current is not None else None
|
||||
|
||||
def _key_atoms(self, value: Any) -> str:
|
||||
"""The footer atoms of the keys that act on the row of ``value``.
|
||||
|
||||
``^R`` acts only on a waiting entry, because a finished entry has left the outbox.
|
||||
Delete acts on each entry, and on no command row.
|
||||
"""
|
||||
atoms = []
|
||||
if self._waiting(value) is not None:
|
||||
atoms.append(_SEND_HINT)
|
||||
if _entry_ident(value) is not None:
|
||||
atoms.append(_DELETE_HINT)
|
||||
return " · ".join(atoms)
|
||||
|
||||
@property
|
||||
def picocalc_lyra_lane(self):
|
||||
"""The lane of the list, with ``Send`` on F3 and ``Delete`` behind it.
|
||||
|
||||
F1/F2 are the section jumps, and F4/F5 are the pager. F3 is the slot that a select
|
||||
list uses for its own verb. Send and Delete have the same subject (the highlighted
|
||||
entry). Thus they are the two halves of that slot, as Read and Remove are in the
|
||||
region editor. Each is dim where it does not act. On a command row, both are dim,
|
||||
not empty: the two actions exist on this screen, but not for that row.
|
||||
"""
|
||||
from .tui.fkeys import FPair
|
||||
|
||||
lane = list(super().picocalc_lyra_lane)
|
||||
current = self._current_choice()
|
||||
lane[2] = FPair(
|
||||
"Send",
|
||||
"retry",
|
||||
opp_label="Delete",
|
||||
opp_action="delete",
|
||||
enabled=self._highlighted_waiting() is not None,
|
||||
opp_enabled=current is not None and current.deletable,
|
||||
)
|
||||
return lane
|
||||
|
||||
def handle(self, action: str, data: str = "") -> None:
|
||||
"""Send the highlighted waiting entry now on ``^R``. Other keys act as in each list."""
|
||||
if action == "retry":
|
||||
ident = self._highlighted_waiting()
|
||||
if ident is not None:
|
||||
self.resolve((_SEND, ident))
|
||||
return
|
||||
super().handle(action, data)
|
||||
|
||||
def _fingerprint(self) -> tuple:
|
||||
"""The shape of the store: which entries exist and the status of each."""
|
||||
return tuple((m.ident, m.status) for m in self._ctx.courier_store.entries())
|
||||
@@ -254,14 +345,27 @@ class CourierOutboxScreen(SelectScreen):
|
||||
self._index = max(0, min(self._index, len(choices) - 1)) if choices else 0
|
||||
|
||||
|
||||
def _entry_ident(value: Any) -> int | None:
|
||||
"""The id of the entry that a row value names (``("msg", ident)``), or ``None``."""
|
||||
if isinstance(value, tuple) and len(value) == 2 and value[0] == "msg":
|
||||
return int(value[1])
|
||||
return None
|
||||
|
||||
|
||||
def _menu_items(ctx: AppContext, entries: list[QueuedMessage]) -> list:
|
||||
"""Build the rows of the screen: the waiting outbox, then the finished history.
|
||||
|
||||
The entry rows are callables with no argument, so that their live state renders again at
|
||||
each paint. The fixed action rows stay plain strings.
|
||||
Each section is a table under its own column header: the status mark, the TARGET (the
|
||||
recipient), and one more lane. In the outbox, that lane is the TRIGGER: what the entry
|
||||
waits for before it goes out. In the history, it is the OUTCOME. A row does not show
|
||||
the message, because Enter opens it (refer to :func:`_open_entry`).
|
||||
|
||||
The entry rows are callables of the render width. Thus their live state renders again
|
||||
at each paint, and their TARGET lane fits the screen (refer to :func:`_target_lane`).
|
||||
The fixed action rows stay plain strings.
|
||||
"""
|
||||
waiting = [m for m in entries if m.status == QUEUED]
|
||||
done = [m for m in entries if m.status != QUEUED]
|
||||
done = [m for m in entries if m.status != QUEUED][:_DONE_SHOWN]
|
||||
|
||||
# One icon column for the whole list, across both sections. The terminal draws ⏳ and
|
||||
# 📨 in two cells, but ✓ ✗ 🗑 in one cell. Thus rows that were written as
|
||||
@@ -271,24 +375,81 @@ def _menu_items(ctx: AppContext, entries: list[QueuedMessage]) -> list:
|
||||
# command icons go where the platform draws no icon lane, and marked_label leaves those
|
||||
# two labels bare. It does not pad them for a mark that is not there.
|
||||
lane = max(icon_lane(_COMMAND_ICONS), _MARK_LANE)
|
||||
# One TARGET lane for both sections, so that the lane after it starts in the same cell
|
||||
# in each. It is never narrower than its label, so the label never runs into the next.
|
||||
target_w = max([cell_len("TARGET")] + [_target_chip(m).cell_len for m in waiting + done])
|
||||
|
||||
items: list = [section_heading("Outbox")]
|
||||
if not waiting:
|
||||
if waiting:
|
||||
items.append(_column_header("TRIGGER", lane, target_w))
|
||||
else:
|
||||
items.append(Separator(" empty — queued messages wait here for their moment"))
|
||||
for message in waiting:
|
||||
items.append(Choice(lambda m=message: _waiting_row(ctx, m, lane), ("msg", message.ident)))
|
||||
items.append(
|
||||
Choice(
|
||||
lambda width, m=message: _waiting_row(
|
||||
ctx, m, lane, _target_lane(lane, target_w, width)
|
||||
),
|
||||
("msg", message.ident),
|
||||
deletable=True,
|
||||
)
|
||||
)
|
||||
items.append(Separator(" ")) # put space between the action and the outbox rows above it
|
||||
items.append(Choice(marked_label("📨", "Queue a message…", "", lane=lane), _QUEUE))
|
||||
|
||||
if done:
|
||||
items.append(section_heading("Finished"))
|
||||
for message in done[:15]:
|
||||
items.append(Choice(lambda m=message: _done_row(m, lane), ("msg", message.ident)))
|
||||
items.append(_column_header("OUTCOME", lane, target_w))
|
||||
for message in done:
|
||||
items.append(
|
||||
Choice(
|
||||
lambda width, m=message: _done_row(
|
||||
m, lane, _target_lane(lane, target_w, width)
|
||||
),
|
||||
("msg", message.ident),
|
||||
deletable=True,
|
||||
)
|
||||
)
|
||||
items.append(Choice(marked_label("🗑", "Clear finished", "", lane=lane), _CLEAR))
|
||||
|
||||
return items
|
||||
|
||||
|
||||
def _column_header(label: str, lane: int, target_w: int) -> Separator:
|
||||
"""The column header of one section: ``TARGET`` over the chips, then ``label``.
|
||||
|
||||
It comes immediately after the heading of its section. Thus it pins with the heading
|
||||
while the rows of the section scroll. It starts after the pointer, the mark, and the
|
||||
space after the mark, so that ``TARGET`` is over the first cell of each chip.
|
||||
|
||||
Args:
|
||||
label: The name of the last lane: ``TRIGGER`` in the outbox, ``OUTCOME`` in the
|
||||
history.
|
||||
lane: The icon column of the list in cells (refer to :func:`_menu_items`).
|
||||
target_w: The width of the widest chip in cells, without the gap after it.
|
||||
"""
|
||||
|
||||
def header(width: int) -> str:
|
||||
# The rows get the width less the 2 cells of the pointer, so the header asks for
|
||||
# the TARGET lane at that width too. Thus each label stays over its lane.
|
||||
target = _target_lane(lane, target_w, width - 2)
|
||||
lanes = [Lane("TARGET", target + _GAP), Lane(label)]
|
||||
return column_header(lanes, width, indent=2 + lane + 1)
|
||||
|
||||
return Separator(header)
|
||||
|
||||
|
||||
def _target_lane(lane: int, target_w: int, avail: int) -> int:
|
||||
"""The width of the TARGET lane in a row that has ``avail`` cells after the pointer.
|
||||
|
||||
The lane is as wide as the widest chip. Where the last lane then gets fewer than
|
||||
:data:`_LAST_MIN` cells, the TARGET lane gives cells back, and a chip that is too wide
|
||||
breaks off on its crack. It is never narrower than its label.
|
||||
"""
|
||||
room = avail - (lane + 1) - _GAP - _LAST_MIN
|
||||
return max(cell_len("TARGET"), min(target_w, room))
|
||||
|
||||
|
||||
def _entry_mark(mark: str, style: str, lane: int) -> Text:
|
||||
"""The status mark of an entry, with a tint, and padded to the icon column of the outbox.
|
||||
|
||||
@@ -302,62 +463,82 @@ def _entry_mark(mark: str, style: str, lane: int) -> Text:
|
||||
lane: The icon column of the list in cells (refer to :func:`_menu_items`).
|
||||
|
||||
Returns:
|
||||
The mark, followed by enough spaces to start the words in the column after it.
|
||||
The mark, followed by enough spaces to start the words in the column after it. The
|
||||
style is a span on the mark only. As the base style of the row, it made each lane
|
||||
after the mark bold.
|
||||
"""
|
||||
text = Text(mark, style=style)
|
||||
text = Text()
|
||||
text.append(mark, style=style)
|
||||
text.append(" " * (lane - cell_len(mark) + 1))
|
||||
return text
|
||||
|
||||
|
||||
def _waiting_row(ctx: AppContext, message: QueuedMessage, lane: int = _MARK_LANE) -> Text:
|
||||
"""One waiting entry: the recipient, the body, and what the entry waits for.
|
||||
def _target_chip(message: QueuedMessage) -> Text:
|
||||
"""The TARGET of an entry: its recipient, as a destination chip.
|
||||
|
||||
The recipient is the destination of the message, so it is a chip that opens on the
|
||||
notch (refer to :func:`~meshterm.ui.widgets.hop_chip`), in the hue of its key.
|
||||
The recipient is the destination of the message, so the chip opens on the notch (refer
|
||||
to :func:`~meshterm.ui.widgets.hop_chip`). A waiting recipient has the hue of its key. A
|
||||
finished entry is history, and all of its row is muted. Thus its chip is muted too.
|
||||
"""
|
||||
if message.status == QUEUED:
|
||||
return name_chip(message.node_name, message.node_key, role=DESTINATION)
|
||||
return hop_chip(PathHop(message.node_name, style="muted"), role=DESTINATION)
|
||||
|
||||
|
||||
def _row(mark: Text, chip: Text, target_w: int, last: Text) -> Text:
|
||||
"""One entry row: the mark, the chip fitted to the TARGET lane, then the last lane."""
|
||||
if chip.cell_len > target_w:
|
||||
chip = cut_to(chip, target_w) # the chip continues past its lane, so it cracks
|
||||
mark.append_text(chip)
|
||||
mark.append(" " * (max(0, target_w - chip.cell_len) + _GAP))
|
||||
mark.append_text(last)
|
||||
return mark
|
||||
|
||||
|
||||
def _trigger(ctx: AppContext, message: QueuedMessage) -> Text:
|
||||
"""The TRIGGER of a waiting entry: what it waits for before it goes out.
|
||||
|
||||
The rules are those of :meth:`~meshterm.services.courier.CourierService.eligible`, in
|
||||
the same order: a schedule, then the backoff after a failed try, then a sign of life.
|
||||
"""
|
||||
row = _entry_mark("⏳", "warn", lane)
|
||||
row.append_text(name_chip(message.node_name, message.node_key, role=DESTINATION))
|
||||
row.append(f" “{_shorten(message.text)}”", style="muted")
|
||||
row.append(" · ", style="muted")
|
||||
now = utcnow()
|
||||
if message.not_before is not None and now < message.not_before:
|
||||
row.append(f"scheduled {_local_stamp(message.not_before)}", style="brand")
|
||||
else:
|
||||
retry = ctx.courier.next_retry_s(message, now)
|
||||
if retry is not None:
|
||||
row.append(
|
||||
f"try {message.attempts} · retry in ~{max(1, round(retry / 60))} m",
|
||||
style="warn",
|
||||
)
|
||||
elif message.attempts > 0:
|
||||
row.append(f"try {message.attempts} · waiting to hear it again", style="muted")
|
||||
elif ctx.courier.heard_recently(message.node_key, now):
|
||||
row.append("contact is fresh — next pass", style="ok")
|
||||
else:
|
||||
row.append("waiting to hear the contact", style="muted")
|
||||
return row
|
||||
return Text(f"at {_local_stamp(message.not_before)}", style="brand")
|
||||
retry = ctx.courier.next_retry_s(message, now)
|
||||
if retry is not None:
|
||||
minutes = max(1, round(retry / 60))
|
||||
return Text(f"retry in ~{minutes} m · try {message.attempts}", style="warn")
|
||||
if message.attempts > 0:
|
||||
return Text(f"when heard again · try {message.attempts}", style="muted")
|
||||
if ctx.courier.heard_recently(message.node_key, now):
|
||||
return Text("next pass — contact is fresh", style="ok")
|
||||
return Text("when heard", style="muted")
|
||||
|
||||
|
||||
def _done_row(message: QueuedMessage, lane: int = _MARK_LANE) -> Text:
|
||||
"""One finished entry: the outcome mark, the recipient, the body, and when it ended.
|
||||
|
||||
The recipient is a destination chip, the same as in the outbox. But a finished entry is
|
||||
history, and all of its row is muted. Thus the chip is muted too.
|
||||
"""
|
||||
if message.status == DELIVERED:
|
||||
row = _entry_mark("✓", "ok", lane)
|
||||
else:
|
||||
row = _entry_mark("✗", "err", lane)
|
||||
row.append_text(hop_chip(PathHop(message.node_name, style="muted"), role=DESTINATION))
|
||||
row.append(f" “{_shorten(message.text)}”", style="muted")
|
||||
def _outcome(message: QueuedMessage) -> str:
|
||||
"""The OUTCOME of a finished entry: how it ended, when, and after how many tries."""
|
||||
when = message.finished or message.created
|
||||
verb = "delivered" if message.status == DELIVERED else "gave up"
|
||||
row.append(
|
||||
f" · {verb} {format_ago(age_seconds(when))}"
|
||||
f" · {message.attempts} attempt{'s' if message.attempts != 1 else ''}",
|
||||
style="muted",
|
||||
tries = f"{message.attempts} attempt{'s' if message.attempts != 1 else ''}"
|
||||
return f"{verb} {format_ago(age_seconds(when))} · {tries}"
|
||||
|
||||
|
||||
def _waiting_row(
|
||||
ctx: AppContext, message: QueuedMessage, lane: int = _MARK_LANE, target_w: int = 0
|
||||
) -> Text:
|
||||
"""One waiting entry: the mark, the TARGET, and the TRIGGER."""
|
||||
return _row(
|
||||
_entry_mark("⏳", "warn", lane), _target_chip(message), target_w, _trigger(ctx, message)
|
||||
)
|
||||
return row
|
||||
|
||||
|
||||
def _done_row(message: QueuedMessage, lane: int = _MARK_LANE, target_w: int = 0) -> Text:
|
||||
"""One finished entry: the outcome mark, the TARGET, and the OUTCOME."""
|
||||
if message.status == DELIVERED:
|
||||
mark = _entry_mark("✓", "ok", lane)
|
||||
else:
|
||||
mark = _entry_mark("✗", "err", lane)
|
||||
return _row(mark, _target_chip(message), target_w, Text(_outcome(message), style="muted"))
|
||||
|
||||
|
||||
# --- the flows --------------------------------------------------------------------------
|
||||
@@ -367,6 +548,10 @@ def _done_row(message: QueuedMessage, lane: int = _MARK_LANE) -> Text:
|
||||
#: an Enter that commits. Esc cancels the queueing step in which the picker is.
|
||||
_PICK_HINT = "↑↓ move · ^←→↑↓ sort · type to filter · Enter select · Esc cancel"
|
||||
|
||||
#: The instruction above the message field: the same when the user writes the message and
|
||||
#: when the user edits it.
|
||||
_MESSAGE_PROMPT = "Delivered as a normal direct message when its moment comes."
|
||||
|
||||
|
||||
class CourierRecipientScreen(ContactListScreen):
|
||||
"""The recipient picker on the shared contact list.
|
||||
@@ -467,8 +652,9 @@ async def _queue_flow(ctx: AppContext, contacts: list[Contact]) -> None:
|
||||
lambda vals: _next_recipient(visit),
|
||||
lambda vals: session.text(
|
||||
f"Message for {vals[0].name}",
|
||||
prompt="Delivered as a normal direct message when its moment comes.",
|
||||
prompt=_MESSAGE_PROMPT,
|
||||
byte_limit=DM_BYTE_LIMIT,
|
||||
compose=True,
|
||||
default=vals[1] or "",
|
||||
),
|
||||
lambda vals: _schedule_step(ctx, vals[0].name),
|
||||
@@ -569,60 +755,97 @@ async def _pick_schedule(ctx: AppContext, name: str):
|
||||
return when
|
||||
|
||||
|
||||
async def _entry_actions(ctx: AppContext, ident: int) -> None:
|
||||
"""Float the action menu of one entry: send now, cancel, or only look at it."""
|
||||
def _not_blank(text: str) -> bool | str:
|
||||
"""The validator of an edited message: an empty message is refused, not sent."""
|
||||
return True if text.strip() else "The message is empty — Esc keeps it as it was."
|
||||
|
||||
|
||||
async def _open_entry(ctx: AppContext, ident: int) -> None:
|
||||
"""Open the message of one entry: to edit while it waits, to read after it finished.
|
||||
|
||||
The edit holds the entry (refer to
|
||||
:meth:`~meshterm.services.courier.CourierService.holding`). Without the hold, a pass
|
||||
can send the old text while the prompt is open. A try that is already in progress
|
||||
cannot be stopped, so the message then opens to read, with a note.
|
||||
"""
|
||||
session = ctx.ui.session
|
||||
store = ctx.courier_store
|
||||
message = store.get(ident)
|
||||
if message is None:
|
||||
return
|
||||
if message.status != QUEUED:
|
||||
# A finished entry has no actions. Show its full text instead.
|
||||
title = f"Message for {message.node_name}"
|
||||
if message.status != QUEUED or ctx.courier.in_flight(ident):
|
||||
body = Text(message.text)
|
||||
body.append(
|
||||
f"\n\n{message.status} · {message.attempts} attempt"
|
||||
f"{'s' if message.attempts != 1 else ''}",
|
||||
style="muted",
|
||||
)
|
||||
await session.message_dialog(body, title=message.node_name)
|
||||
if message.status != QUEUED:
|
||||
body.append(f"\n\n{_outcome(message)}", style="muted")
|
||||
else:
|
||||
body.append("\n\nsending now — edit it after this attempt", style="muted")
|
||||
await session.message_dialog(body, title=title)
|
||||
return
|
||||
# One measured column for both rows. 📤 draws two cells and ✗ draws one cell. The Cancel
|
||||
# row measured only its own mark, so its words started one column to the left of the
|
||||
# words of Send now. Where the platform draws no icon lane, both rows have no icon, and
|
||||
# the err tint of Cancel moves onto its words.
|
||||
lane = icon_lane(("📤", "✗"))
|
||||
items = [
|
||||
Choice(marked_label("📤", "Send now — one forced attempt", "", lane=lane), "send"),
|
||||
Choice(marked_label("✗", "Cancel this message", "err", lane=lane), "cancel"),
|
||||
]
|
||||
picked = await session.select(
|
||||
f"{message.node_name} — “{_shorten(message.text, 28)}”",
|
||||
items,
|
||||
filterable=False,
|
||||
footer_hint="↑↓ move · Enter select · Esc back",
|
||||
)
|
||||
if picked == "cancel":
|
||||
store.cancel(ident)
|
||||
elif picked == "send":
|
||||
try:
|
||||
async with ctx.ui.busy_overlay(f"sending to {message.node_name}…"):
|
||||
outcome = await ctx.courier.attempt_now(ident)
|
||||
except Exception as exc: # noqa: BLE001 - show the failure, and keep the queue
|
||||
await session.message_dialog(Text(f"send failed: {exc}", style="err"), title="Courier")
|
||||
return
|
||||
notes = {
|
||||
"delivered": Text("✓ delivered — acknowledged by the contact", style="ok"),
|
||||
"no ack": Text(
|
||||
"sent, but no acknowledgement — it stays queued and the courier "
|
||||
"will retry with backoff",
|
||||
style="warn",
|
||||
),
|
||||
"gave up": Text("no acknowledgement — the retry budget is spent", style="err"),
|
||||
"unknown contact": Text(
|
||||
"the device's contact list doesn't know this contact yet; it stays queued",
|
||||
style="warn",
|
||||
),
|
||||
"busy": Text("another delivery is in flight — try again in a moment", style="muted"),
|
||||
"gone": Text("this entry is no longer queued", style="muted"),
|
||||
}
|
||||
await session.message_dialog(notes.get(outcome, Text(outcome)), title="Courier")
|
||||
with ctx.courier.holding(ident):
|
||||
text = await session.text(
|
||||
title,
|
||||
prompt=_MESSAGE_PROMPT,
|
||||
default=message.text,
|
||||
validate=_not_blank,
|
||||
byte_limit=DM_BYTE_LIMIT,
|
||||
compose=True,
|
||||
)
|
||||
if text is None or text == message.text:
|
||||
return
|
||||
if not store.edit(ident, text):
|
||||
# A late acknowledgement can finish the entry while the prompt is open.
|
||||
await session.message_dialog(
|
||||
Text("this message left the outbox during the edit — it was not changed", style="warn"),
|
||||
title="Courier",
|
||||
)
|
||||
|
||||
|
||||
async def _delete_entry(ctx: AppContext, ident: int) -> None:
|
||||
"""Ask to delete one entry (waiting or finished), with the red confirm of a delete."""
|
||||
store = ctx.courier_store
|
||||
message = store.get(ident)
|
||||
if message is None:
|
||||
return
|
||||
if message.status == QUEUED:
|
||||
prompt = f"Delete the message for {message.node_name}? It will not be sent."
|
||||
else:
|
||||
prompt = f"Delete the message for {message.node_name} from the history?"
|
||||
if await ctx.ui.dialog(
|
||||
prompt,
|
||||
[("Cancel", False), ("Delete", True)],
|
||||
title="Delete message",
|
||||
default=1,
|
||||
destructive=True,
|
||||
):
|
||||
store.delete(ident)
|
||||
|
||||
|
||||
async def _send_now(ctx: AppContext, ident: int) -> None:
|
||||
"""Force one delivery try of a waiting entry, and show the outcome in a dialog."""
|
||||
session = ctx.ui.session
|
||||
message = ctx.courier_store.get(ident)
|
||||
if message is None or message.status != QUEUED:
|
||||
return
|
||||
try:
|
||||
async with ctx.ui.busy_overlay(f"sending to {message.node_name}…"):
|
||||
outcome = await ctx.courier.attempt_now(ident)
|
||||
except Exception as exc: # noqa: BLE001 - show the failure, and keep the queue
|
||||
await session.message_dialog(Text(f"send failed: {exc}", style="err"), title="Courier")
|
||||
return
|
||||
notes = {
|
||||
"delivered": Text("✓ delivered — acknowledged by the contact", style="ok"),
|
||||
"no ack": Text(
|
||||
"sent, but no acknowledgement — it stays queued and the courier "
|
||||
"will retry with backoff",
|
||||
style="warn",
|
||||
),
|
||||
"gave up": Text("no acknowledgement — the retry budget is spent", style="err"),
|
||||
"unknown contact": Text(
|
||||
"the device's contact list doesn't know this contact yet; it stays queued",
|
||||
style="warn",
|
||||
),
|
||||
"busy": Text("another delivery is in flight — try again in a moment", style="muted"),
|
||||
"gone": Text("this entry is no longer queued", style="muted"),
|
||||
}
|
||||
await session.message_dialog(notes.get(outcome, Text(outcome)), title="Courier")
|
||||
@@ -187,7 +187,12 @@ class LineEditor:
|
||||
return i
|
||||
|
||||
def render(
|
||||
self, mask: bool = False, *, overflow_at: int | None = None, slots: int | None = None
|
||||
self,
|
||||
mask: bool = False,
|
||||
*,
|
||||
overflow_at: int | None = None,
|
||||
slots: int | None = None,
|
||||
compose: bool = False,
|
||||
) -> Text:
|
||||
"""Render the current line with a reverse-video cursor cell.
|
||||
|
||||
@@ -200,12 +205,22 @@ class LineEditor:
|
||||
slots: When set, render exactly this number of fixed positions (a masked PIN
|
||||
field). A typed position shows a bullet, and a blank position shows a muted
|
||||
centre dot. This argument has priority over ``mask`` and ``overflow_at``.
|
||||
compose: When ``True``, draw the line as the compose line of a chat draws it:
|
||||
the ``›`` in the ``cursor`` white and the text in the ``compose`` white
|
||||
(refer to :meth:`~meshterm.ui.compose.MentionEditor.render_line`). Thus a
|
||||
message that the user writes outside a chat looks the same as in a chat.
|
||||
"""
|
||||
if slots is not None:
|
||||
return self._render_slots(slots)
|
||||
shown = MASK_MARK * len(self.text) if mask else self.text
|
||||
text = Text("› ", style="accent")
|
||||
self._append_run(text, shown, 0, len(shown), overflow_at)
|
||||
if compose:
|
||||
# The style goes on the ``›`` alone, as in the chat. As the base style of the
|
||||
# line, it also colours the typed text, and the compose white is then bold.
|
||||
text = Text()
|
||||
text.append("› ", style="cursor")
|
||||
else:
|
||||
text = Text("› ", style="accent")
|
||||
self._append_run(text, shown, 0, len(shown), overflow_at, "compose" if compose else None)
|
||||
if self.cursor >= len(shown): # cursor past the last character → trailing block
|
||||
text.append(" ", style="reverse")
|
||||
return text
|
||||
@@ -293,6 +308,7 @@ class TextScreen(_KeylessDialog):
|
||||
help_text: str = "",
|
||||
password: bool = False,
|
||||
byte_limit: int | None = None,
|
||||
compose: bool = False,
|
||||
footer_hint: str = "Enter accept · Esc cancel",
|
||||
) -> None:
|
||||
"""Build a text prompt.
|
||||
@@ -312,6 +328,8 @@ class TextScreen(_KeylessDialog):
|
||||
submission when the text is longer than the limit. Use it for a field that
|
||||
feeds a packet with a size limit (a direct message, a courier entry). Keep
|
||||
``None`` for a field with no limit.
|
||||
compose: When ``True``, the field is a message, and it has the colours of the
|
||||
compose line of a chat (refer to :meth:`LineEditor.render`).
|
||||
footer_hint: The key hint in the footer.
|
||||
"""
|
||||
super().__init__()
|
||||
@@ -323,6 +341,7 @@ class TextScreen(_KeylessDialog):
|
||||
self._help = help_text
|
||||
self._password = password
|
||||
self._byte_limit = byte_limit
|
||||
self._compose = compose
|
||||
self._error = ""
|
||||
|
||||
@property
|
||||
@@ -358,7 +377,7 @@ class TextScreen(_KeylessDialog):
|
||||
if self._prompt:
|
||||
parts.append(Text(self._prompt))
|
||||
parts.append(Text(""))
|
||||
field = self._editor.render(mask=self._password)
|
||||
field = self._editor.render(mask=self._password, compose=self._compose)
|
||||
if self._byte_limit is not None:
|
||||
# The gauge pins to the right edge of the field: a steady fuel gauge in the corner,
|
||||
# exactly as the chat compose bar draws it (both through ``byte_counter``).
|
||||
|
||||
@@ -1526,6 +1526,7 @@ class TuiSession:
|
||||
help_text: str = "",
|
||||
password: bool = False,
|
||||
byte_limit: int | None = None,
|
||||
compose: bool = False,
|
||||
floating: bool = False,
|
||||
) -> str | None:
|
||||
"""Show a text prompt. Return the string, or ``None`` if the user cancelled.
|
||||
@@ -1539,6 +1540,9 @@ class TuiSession:
|
||||
``byte_limit`` puts the shared UTF-8 byte gauge on the field, and blocks a submission
|
||||
that is longer than the limit. Use it for a field that goes into a packet with a
|
||||
maximum size (refer to :class:`TextScreen`).
|
||||
|
||||
``compose`` gives the field the colours of the compose line of a chat. Use it for a
|
||||
field that holds a message.
|
||||
"""
|
||||
screen = TextScreen(
|
||||
title,
|
||||
@@ -1548,6 +1552,7 @@ class TuiSession:
|
||||
help_text=help_text,
|
||||
password=password,
|
||||
byte_limit=byte_limit,
|
||||
compose=compose,
|
||||
)
|
||||
runner = self.run_dialog if floating else self.run_screen
|
||||
result = await runner(screen)
|
||||
|
||||
+288
-35
@@ -25,7 +25,6 @@ from meshterm.services.courier import FRESH_S, MAX_ATTEMPTS, CourierService
|
||||
from meshterm.ui.courier_screen import (
|
||||
CANCEL_SCHEDULE,
|
||||
WHEN_HEARD,
|
||||
_entry_actions,
|
||||
_pick_schedule,
|
||||
parse_clock,
|
||||
)
|
||||
@@ -121,6 +120,32 @@ def test_store_caps_the_finished_history(tmp_path: Path) -> None:
|
||||
assert store.get(keeper.ident) is not None
|
||||
|
||||
|
||||
def test_store_edits_a_waiting_body_and_deletes_any_entry(tmp_path: Path) -> None:
|
||||
"""An edit changes only a waiting body. A delete removes an entry of either section.
|
||||
|
||||
A finished body is what went out, so it never changes. The edit keeps the schedule and
|
||||
the attempts, because the backoff counts tries to reach the contact, not versions of
|
||||
the text.
|
||||
"""
|
||||
path = tmp_path / "courier.json"
|
||||
store = CourierStore(path)
|
||||
when = utcnow() + timedelta(hours=1)
|
||||
waiting = store.queue(NODE, "Hub", "first draft", not_before=when)
|
||||
store.note_attempt(waiting.ident)
|
||||
done = store.queue(NODE, "Hub", "sent text")
|
||||
store.mark_delivered(done.ident)
|
||||
|
||||
assert store.edit(waiting.ident, "second draft") is True
|
||||
again = CourierStore(path).get(waiting.ident)
|
||||
assert again.text == "second draft" and again.not_before == when and again.attempts == 1
|
||||
assert store.edit(done.ident, "rewritten") is False
|
||||
assert store.get(done.ident).text == "sent text"
|
||||
|
||||
assert store.delete(done.ident) is True and store.get(done.ident) is None
|
||||
assert store.delete(waiting.ident) is True and store.entries() == []
|
||||
assert store.delete(waiting.ident) is False
|
||||
|
||||
|
||||
# --- eligibility -------------------------------------------------------------------------
|
||||
|
||||
|
||||
@@ -251,6 +276,40 @@ async def test_attempt_now_forces_a_send(tmp_path: Path) -> None:
|
||||
assert await service.attempt_now(entry.ident) == "gone" # the entry is already settled
|
||||
|
||||
|
||||
async def test_a_held_entry_waits_while_the_user_edits_it(tmp_path: Path) -> None:
|
||||
"""A pass does not try an entry that the user edits, and tries it after the edit.
|
||||
|
||||
Without the hold, a pass could send the old text while the edit prompt is open.
|
||||
"""
|
||||
service = _service(tmp_path, [True])
|
||||
ctx = service._ctx
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "hello")
|
||||
service._heard[NODE] = utcnow()
|
||||
with service.holding(entry.ident):
|
||||
await service._pass()
|
||||
assert ctx.chat.sent == []
|
||||
await service._pass()
|
||||
assert ctx.chat.sent == [("Hub", "hello")]
|
||||
|
||||
|
||||
async def test_in_flight_names_the_entry_that_a_try_sends(tmp_path: Path) -> None:
|
||||
"""While a try runs, ``in_flight`` is true for its entry only. After the try, it is false."""
|
||||
service = _service(tmp_path, [True])
|
||||
ctx = service._ctx
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "hello")
|
||||
seen: list[tuple[bool, bool]] = []
|
||||
send = ctx.chat.send_direct
|
||||
|
||||
async def spy(contact, text, **kwargs): # noqa: ANN001, ANN202
|
||||
seen.append((service.in_flight(entry.ident), service.in_flight(entry.ident + 1)))
|
||||
return await send(contact, text, **kwargs)
|
||||
|
||||
ctx.chat.send_direct = spy
|
||||
await service.attempt_now(entry.ident)
|
||||
assert seen == [(True, False)]
|
||||
assert not service.in_flight(entry.ident)
|
||||
|
||||
|
||||
# --- the scripted CLI actions -------------------------------------------------------------
|
||||
|
||||
|
||||
@@ -534,7 +593,7 @@ def test_outbox_rows_recompute_live_state_per_repaint(tmp_path: Path) -> None:
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "patience")
|
||||
screen = CourierOutboxScreen(ctx)
|
||||
assert "waiting to hear the contact" in _outbox_plain(screen)
|
||||
assert "when heard" in _outbox_plain(screen)
|
||||
|
||||
# An attempt just happened. The same row now shows the countdown to the next attempt.
|
||||
# ``refresh()`` is not necessary, because the callable title reads the entry again at
|
||||
@@ -561,9 +620,9 @@ def test_outbox_draws_each_recipient_as_a_destination_chip(tmp_path: Path, power
|
||||
def _title_plain(choice) -> str:
|
||||
"""The label of a row as plain text.
|
||||
|
||||
It resolves a live (callable) title in the same way as a paint.
|
||||
It resolves a live (callable) title at each read, in the same way as a paint.
|
||||
"""
|
||||
title = choice.title() if callable(choice.title) else choice.title
|
||||
title = choice.label
|
||||
return title.plain if isinstance(title, Text) else title
|
||||
|
||||
|
||||
@@ -583,22 +642,6 @@ def _outbox_titles(tmp_path: Path) -> list[str]:
|
||||
return [_title_plain(choice) for choice in CourierOutboxScreen(ctx)._choices()]
|
||||
|
||||
|
||||
async def _entry_action_titles(tmp_path: Path) -> list[str]:
|
||||
"""The labels in the action menu of a waiting entry (the menu closes with no answer)."""
|
||||
offered: list = []
|
||||
|
||||
class _Session:
|
||||
async def select(self, title, items, **kwargs):
|
||||
offered.extend(items)
|
||||
return None
|
||||
|
||||
store = CourierStore(tmp_path / "courier.json")
|
||||
entry = store.queue(NODE, "Hub", "hello")
|
||||
ctx = SimpleNamespace(ui=SimpleNamespace(session=_Session()), courier_store=store)
|
||||
await _entry_actions(ctx, entry.ident)
|
||||
return [_title_plain(choice) for choice in offered]
|
||||
|
||||
|
||||
def _word_starts(rows: list[str], leads: dict[str, str]) -> set[int]:
|
||||
"""The display cell where the first word of each row starts.
|
||||
|
||||
@@ -612,33 +655,29 @@ def _word_starts(rows: list[str], leads: dict[str, str]) -> set[int]:
|
||||
return starts
|
||||
|
||||
|
||||
async def test_courier_rows_start_every_label_in_the_same_cell(tmp_path: Path) -> None:
|
||||
"""The two lists of the courier have one icon column, with no regard for the width of each mark.
|
||||
def test_courier_rows_start_every_label_in_the_same_cell(tmp_path: Path) -> None:
|
||||
"""The outbox has one icon column, with no regard for the width of each mark.
|
||||
|
||||
The outbox has marks of two cells (⏳ a waiting entry, 📨 the queue row) and marks of one
|
||||
cell (✓ ✗ a finished entry, 🗑 the clear row). It wrote each as ``mark + " "``. Thus a
|
||||
finished recipient was one column to the left of a waiting recipient, and *Clear
|
||||
finished* was one column to the left of *Queue a message…*. The actions of an entry
|
||||
had the same fault with 📤 over ✗. The measure is cells, not characters, because the
|
||||
terminal aligns cells.
|
||||
finished* was one column to the left of *Queue a message…*. The measure is cells, not
|
||||
characters, because the terminal aligns cells.
|
||||
"""
|
||||
outbox = {"Waiting": "⏳", "Queue": "📨", "Landed": "✓", "Lost": "✗", "Clear": "🗑"}
|
||||
actions = {"Send": "📤", "Cancel": "✗"}
|
||||
assert {cell_len(mark) for mark in outbox.values()} == {1, 2}, "a mixed list, or no proof"
|
||||
assert {cell_len(mark) for mark in actions.values()} == {1, 2}
|
||||
|
||||
assert len(_word_starts(_outbox_titles(tmp_path), outbox)) == 1
|
||||
assert len(_word_starts(await _entry_action_titles(tmp_path), actions)) == 1
|
||||
|
||||
|
||||
async def test_courier_command_rows_go_bare_where_the_platform_draws_no_icons(
|
||||
def test_courier_command_rows_go_bare_where_the_platform_draws_no_icons(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
"""If there is no icon lane, the command icons go with no padding. The entry marks stay.
|
||||
|
||||
The ✓, ✗, or ⏳ of an entry is its outcome, not decoration. Thus the PicoCalc keeps it,
|
||||
and it keeps those rows in line with each other. The queue, clear, send, and cancel rows
|
||||
lose their icons in the same way as each other command row there.
|
||||
and it keeps those rows in line with each other. The queue and clear rows lose their
|
||||
icons in the same way as each other command row there.
|
||||
"""
|
||||
from meshterm.platforms import PICOCALC_LYRA, REGULAR, set_platform
|
||||
|
||||
@@ -648,14 +687,228 @@ async def test_courier_command_rows_go_bare_where_the_platform_draws_no_icons(
|
||||
assert "Queue a message…" in rows and "Clear finished" in rows
|
||||
marks = {"Waiting": "⏳", "Landed": "✓", "Lost": "✗"}
|
||||
assert len(_word_starts(rows, marks)) == 1
|
||||
assert await _entry_action_titles(tmp_path / "actions") == [
|
||||
"Send now — one forced attempt",
|
||||
"Cancel this message",
|
||||
]
|
||||
finally:
|
||||
set_platform(REGULAR)
|
||||
|
||||
|
||||
def _cell(line: str, word: str) -> int:
|
||||
"""The display cell where ``word`` starts in ``line``."""
|
||||
return cell_len(line[: line.index(word)])
|
||||
|
||||
|
||||
def test_outbox_rows_are_target_and_trigger_under_column_headers(tmp_path: Path) -> None:
|
||||
"""Each section is a table: TARGET and TRIGGER in the outbox, TARGET and OUTCOME after it.
|
||||
|
||||
A row does not show its message, because Enter opens it. Each section has its own
|
||||
header, so the lane after TARGET has one meaning in each section. That lane starts in
|
||||
the same cell in both sections, and each label is over its lane.
|
||||
"""
|
||||
from meshterm.ui.courier_screen import CourierOutboxScreen
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
ctx.courier_store.queue(NODE, "Waiting", "hold this text")
|
||||
landed = ctx.courier_store.queue(NODE, "Landed Longer Name", "got it")
|
||||
ctx.courier_store.mark_delivered(landed.ident)
|
||||
lines = _outbox_plain(CourierOutboxScreen(ctx)).splitlines()
|
||||
|
||||
assert not any("hold this" in line or "got it" in line for line in lines)
|
||||
trigger = next(line for line in lines if "TRIGGER" in line)
|
||||
outcome = next(line for line in lines if "OUTCOME" in line)
|
||||
waiting = next(line for line in lines if "Waiting" in line)
|
||||
done = next(line for line in lines if "Landed" in line)
|
||||
assert _cell(trigger, "TARGET") == _cell(waiting, "Waiting") == _cell(done, "Landed")
|
||||
assert _cell(outcome, "TARGET") == _cell(trigger, "TARGET")
|
||||
assert _cell(trigger, "TRIGGER") == _cell(waiting, "when heard")
|
||||
assert _cell(outcome, "OUTCOME") == _cell(done, "delivered") == _cell(trigger, "TRIGGER")
|
||||
|
||||
|
||||
def test_outbox_triggers_name_what_each_entry_waits_for(tmp_path: Path) -> None:
|
||||
"""The TRIGGER lane says what sends the entry: a time, the end of a backoff, or a contact."""
|
||||
from meshterm.ui.courier_screen import _trigger
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
store = ctx.courier_store
|
||||
later = store.queue(NODE, "Hub", "x", not_before=utcnow() + timedelta(hours=2))
|
||||
assert _trigger(ctx, later).plain.startswith("at ")
|
||||
plain = store.queue(NODE, "Hub", "y")
|
||||
assert _trigger(ctx, plain).plain == "when heard"
|
||||
ctx.courier._heard[NODE] = utcnow()
|
||||
assert _trigger(ctx, plain).plain == "next pass — contact is fresh"
|
||||
store.note_attempt(plain.ident)
|
||||
assert _trigger(ctx, store.get(plain.ident)).plain == "retry in ~5 m · try 1"
|
||||
|
||||
|
||||
def test_outbox_cut_ends_on_an_ellipsis_not_on_a_stray_crack(tmp_path: Path, powerline) -> None:
|
||||
"""A row that is wider than the screen ends in ``…``, not in a half block of the chip fill.
|
||||
|
||||
The cut lands in the TRIGGER text, after the chip. The crack is for a cut inside a
|
||||
chip. Here it once drew a half block in the fill of the TARGET chip at the right edge of
|
||||
the row, far from the chip.
|
||||
"""
|
||||
from meshterm.ui.courier_screen import CourierOutboxScreen
|
||||
from meshterm.ui.pathline import CRACK_TAIL
|
||||
|
||||
powerline(True)
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
ctx.courier_store.queue(NODE, "Hub", "hello")
|
||||
ctx.courier._heard[NODE] = utcnow() # the longest trigger: "next pass — contact is fresh"
|
||||
body = _outbox_plain(CourierOutboxScreen(ctx), 40).splitlines()
|
||||
row = next(line for line in body if "⏳" in line)
|
||||
assert cell_len(row) == 40
|
||||
assert row.endswith("…") and CRACK_TAIL not in row
|
||||
|
||||
|
||||
def test_a_long_target_gives_cells_to_the_trigger(tmp_path: Path, powerline) -> None:
|
||||
"""On a narrow screen, a long name breaks off on its crack, and the trigger stays readable.
|
||||
|
||||
The TARGET lane is as wide as the widest chip only while the TRIGGER lane keeps its
|
||||
minimum. The header follows the same lane, so TRIGGER stays over the triggers.
|
||||
"""
|
||||
from meshterm.ui.courier_screen import _LAST_MIN, CourierOutboxScreen
|
||||
from meshterm.ui.pathline import CRACK_TAIL
|
||||
|
||||
powerline(True)
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
ctx.courier_store.queue(NODE, "A Rather Long Contact Name For Width", "hello")
|
||||
lines = _outbox_plain(CourierOutboxScreen(ctx), 53).splitlines()
|
||||
header = next(line for line in lines if "TARGET" in line)
|
||||
row = next(line for line in lines if "⏳" in line)
|
||||
assert row.rstrip().endswith("when heard")
|
||||
assert CRACK_TAIL in row # the chip continues past its lane
|
||||
assert _cell(header, "TRIGGER") == _cell(row, "when heard") <= 53 - _LAST_MIN
|
||||
|
||||
|
||||
def test_outbox_keys_act_only_on_the_rows_they_name(tmp_path: Path) -> None:
|
||||
"""``^R`` sends a waiting entry, Delete asks to remove an entry, and neither acts elsewhere.
|
||||
|
||||
The footer and the F-key lane name each key only on the rows on which it acts.
|
||||
"""
|
||||
from meshterm.ui.courier_screen import _QUEUE, CourierOutboxScreen
|
||||
from meshterm.ui.tui import DeleteRequest
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
waiting = ctx.courier_store.queue(NODE, "Waiting", "hold this")
|
||||
landed = ctx.courier_store.queue(NODE, "Landed", "got it")
|
||||
ctx.courier_store.mark_delivered(landed.ident)
|
||||
resolved: list = []
|
||||
|
||||
def on(value) -> CourierOutboxScreen: # noqa: ANN001
|
||||
screen = CourierOutboxScreen(ctx, default=value)
|
||||
screen.resolve = resolved.append # type: ignore[method-assign]
|
||||
return screen
|
||||
|
||||
screen = on(("msg", waiting.ident))
|
||||
assert screen.footer_hint == (
|
||||
"↑↓ move · type to filter · Enter open · ^R send · Del delete · Esc back"
|
||||
)
|
||||
assert cell_len(screen.footer_hint) <= 72
|
||||
slot = screen.picocalc_lyra_lane[2]
|
||||
assert (slot.label, slot.opp_label, slot.enabled, slot.opp_enabled) == (
|
||||
"Send",
|
||||
"Delete",
|
||||
True,
|
||||
True,
|
||||
)
|
||||
screen.handle("retry")
|
||||
assert resolved.pop() == ("send", waiting.ident)
|
||||
|
||||
screen = on(("msg", landed.ident))
|
||||
assert "^R" not in screen.footer_hint and "Del delete" in screen.footer_hint
|
||||
assert not screen.picocalc_lyra_lane[2].enabled
|
||||
screen.handle("retry")
|
||||
assert resolved == [] # a finished entry left the outbox, so there is nothing to send
|
||||
screen.handle("delete")
|
||||
assert resolved.pop() == DeleteRequest(("msg", landed.ident))
|
||||
|
||||
screen = on(_QUEUE)
|
||||
assert screen.footer_hint == "↑↓ move · type to filter · Enter open · Esc back"
|
||||
screen.handle("delete")
|
||||
screen.handle("retry")
|
||||
assert resolved == []
|
||||
|
||||
|
||||
class _EntrySession:
|
||||
"""A script for the dialogs of one entry. It records what MeshTerm asked and showed."""
|
||||
|
||||
def __init__(self, answer: str | None = None, on_text=None) -> None: # noqa: ANN001
|
||||
self.answer = answer
|
||||
self.on_text = on_text
|
||||
self.asked: list[dict] = []
|
||||
self.shown: list[tuple[str, str]] = []
|
||||
|
||||
async def text(self, title, **kwargs): # noqa: ANN001, ANN201
|
||||
self.asked.append({"title": title, **kwargs})
|
||||
if self.on_text is not None:
|
||||
await self.on_text()
|
||||
return self.answer
|
||||
|
||||
async def message_dialog(self, body, *, title=""): # noqa: ANN001, ANN201
|
||||
self.shown.append((title, body.plain if isinstance(body, Text) else str(body)))
|
||||
|
||||
|
||||
async def test_enter_on_a_waiting_entry_edits_its_message(tmp_path: Path) -> None:
|
||||
"""Enter opens the message of a waiting entry in a compose field, and Enter there saves it.
|
||||
|
||||
The entry is held while the prompt is open. Thus a pass in that time sends nothing,
|
||||
and the message that goes out later is the edited one.
|
||||
"""
|
||||
from meshterm.ui.courier_screen import _open_entry
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "old text")
|
||||
ctx.courier._heard[NODE] = utcnow()
|
||||
session = _EntrySession("new text", on_text=ctx.courier._pass)
|
||||
ctx.ui = SimpleNamespace(session=session)
|
||||
|
||||
await _open_entry(ctx, entry.ident)
|
||||
asked = session.asked[0]
|
||||
assert asked["title"] == "Message for Hub"
|
||||
assert asked["default"] == "old text" and asked["compose"] is True
|
||||
assert ctx.chat.sent == [] # the pass during the prompt left the held entry alone
|
||||
assert ctx.courier_store.get(entry.ident).text == "new text"
|
||||
await ctx.courier._pass()
|
||||
assert ctx.chat.sent == [("Hub", "new text")]
|
||||
|
||||
|
||||
async def test_enter_on_a_finished_entry_shows_its_message(tmp_path: Path) -> None:
|
||||
"""A finished message is history. Enter shows it with its outcome, and asks nothing."""
|
||||
from meshterm.ui.courier_screen import _open_entry
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "what went out")
|
||||
ctx.courier_store.mark_delivered(entry.ident)
|
||||
session = _EntrySession()
|
||||
ctx.ui = SimpleNamespace(session=session)
|
||||
|
||||
await _open_entry(ctx, entry.ident)
|
||||
assert session.asked == []
|
||||
title, body = session.shown[0]
|
||||
assert title == "Message for Hub"
|
||||
assert body.startswith("what went out") and "delivered" in body
|
||||
|
||||
|
||||
async def test_delete_asks_in_red_and_removes_the_entry(tmp_path: Path) -> None:
|
||||
"""Delete is a red Cancel/Delete confirm. Cancel keeps the entry, and Delete removes it."""
|
||||
from meshterm.ui.courier_screen import _delete_entry
|
||||
|
||||
ctx = _outbox_ctx(tmp_path)
|
||||
entry = ctx.courier_store.queue(NODE, "Hub", "nope")
|
||||
asked: list[dict] = []
|
||||
answers = [False, True]
|
||||
|
||||
async def dialog(prompt, buttons, **kwargs): # noqa: ANN001, ANN202
|
||||
asked.append({"prompt": prompt, "buttons": buttons, **kwargs})
|
||||
return answers.pop(0)
|
||||
|
||||
ctx.ui = SimpleNamespace(dialog=dialog)
|
||||
await _delete_entry(ctx, entry.ident)
|
||||
assert ctx.courier_store.get(entry.ident) is not None
|
||||
await _delete_entry(ctx, entry.ident)
|
||||
assert ctx.courier_store.get(entry.ident) is None
|
||||
assert asked[0]["destructive"] is True and asked[0]["default"] == 1
|
||||
assert [label for label, _value in asked[0]["buttons"]] == ["Cancel", "Delete"]
|
||||
|
||||
|
||||
# --- the recipient picker ----------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
@@ -1418,6 +1418,28 @@ def test_text_screen_byte_limit_gauges_and_blocks_an_oversize_entry() -> None:
|
||||
assert _run(screen, "enter") == "hello wor"
|
||||
|
||||
|
||||
def test_text_screen_compose_field_has_the_colours_of_the_chat_compose_line() -> None:
|
||||
"""A message field draws its ``›`` in the cursor white and its text in the compose white.
|
||||
|
||||
These are the colours of the compose line of a chat. A plain field keeps the accent
|
||||
``›`` and the default colour of the text.
|
||||
"""
|
||||
from meshterm.ui.tui.prompt import LineEditor
|
||||
|
||||
editor = LineEditor("hi")
|
||||
line = editor.render(compose=True)
|
||||
assert not str(line.style) # a base style also colours the typed text
|
||||
prompt = {str(span.style) for span in line.spans if span.start == 0}
|
||||
typed = {str(span.style) for span in line.spans if (span.start, span.end) == (2, 3)}
|
||||
assert (prompt, typed) == ({"cursor"}, {"compose"})
|
||||
plain = editor.render()
|
||||
assert str(plain.style) == "accent"
|
||||
assert "compose" not in {str(span.style) for span in plain.spans}
|
||||
|
||||
screen = TextScreen("Message for Hub", byte_limit=10, compose=True)
|
||||
assert screen._compose is True
|
||||
|
||||
|
||||
def test_line_editor_word_motion() -> None:
|
||||
"""Ctrl+Left and Ctrl+Right move by word.
|
||||
|
||||
|
||||
Reference in new issue
Block a user