devicectl-core 0.1.0__py3-none-any.whl

devicectl/progress.py

@@ -0,0 +1,77 @@
+"""Terminal progress rendering for whatever takes long enough to need it.
+
+Plain stderr ``#``/``-`` bars carrying a percentage, elapsed time and an
+estimate of what is left.  The live-updating single line is used only when
+stderr is a TTY; piped, or in ``--debug``, the callers log discrete lines
+instead.  No progress-bar dependency -- a few dozen lines do the job.
+"""
+
+from __future__ import annotations
+
+import sys
+
+# Width, in characters, of the textual progress bar.
+PROGRESS_BAR_WIDTH = 24
+# Don't redraw more often than this.  It smooths the burst at the start of an
+# upload, where the first chunks only fill a buffer, and it keeps a stream of
+# small blocks from redrawing faster than a terminal can usefully show.
+PROGRESS_MIN_INTERVAL_S = 0.1
+# Granularity of a countdown while waiting for a device to come back.
+PROGRESS_TICK_S = 1.0
+# With no live bar to draw, log a progress line each time this fraction of the
+# body has gone by (0.1 -> every ~10%).
+PROGRESS_DEBUG_STEP = 0.1
+
+BYTES_PER_KB = 1000
+BYTES_PER_MB = 1_000_000
+SECONDS_PER_MINUTE = 60
+# Here because the two programs had each worked out for themselves, in four
+# modules apiece, how long an hour and a day are.
+SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE
+SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR
+
+
+def fmt_duration(seconds: float) -> str:
+    """Format a duration compactly, e.g. ``42s`` or ``3m05s``."""
+    total = int(seconds)
+    if total < SECONDS_PER_MINUTE:
+        return f"{total}s"
+    return f"{total // SECONDS_PER_MINUTE}m{total % SECONDS_PER_MINUTE:02d}s"
+
+
+def bar(fraction: float) -> str:
+    """Return a fixed-width ``#``/``-`` bar for ``fraction`` clamped to [0, 1]."""
+    fraction = max(0.0, min(1.0, fraction))
+    filled = int(fraction * PROGRESS_BAR_WIDTH)
+    return "#" * filled + "-" * (PROGRESS_BAR_WIDTH - filled)
+
+
+def write_live(text: str) -> None:
+    """Overwrite the current stderr line with ``text`` (only when stderr is a TTY)."""
+    if sys.stderr.isatty():
+        sys.stderr.write("\r\033[K" + text)  # \r + clear-to-end-of-line
+        sys.stderr.flush()
+
+
+def end_live() -> None:
+    """End a live progress line with a newline (only when stderr is a TTY)."""
+    if sys.stderr.isatty():
+        sys.stderr.write("\n")
+        sys.stderr.flush()
+
+
+__all__ = [
+    "BYTES_PER_KB",
+    "BYTES_PER_MB",
+    "PROGRESS_BAR_WIDTH",
+    "PROGRESS_DEBUG_STEP",
+    "PROGRESS_MIN_INTERVAL_S",
+    "PROGRESS_TICK_S",
+    "SECONDS_PER_DAY",
+    "SECONDS_PER_HOUR",
+    "SECONDS_PER_MINUTE",
+    "bar",
+    "end_live",
+    "fmt_duration",
+    "write_live",
+]

devicectl/report.py

@@ -0,0 +1,67 @@
+"""Where a long operation says what it is doing.
+
+A firmware upgrade takes minutes and has plenty to say meanwhile: which step
+it is on, how far the upload has got, what the device answered while it
+rebooted.  A terminal draws that as a live line and a browser gets it over
+an event stream, so the operation says it to a *reporter* rather than
+printing it -- which is what lets both front ends drive the same code.
+
+Every method is optional and none of them may raise: a reporter is called
+from the middle of an upgrade, and a broken progress bar must never fail
+one.  :data:`SILENT` is the default everywhere -- it discards the lot, which
+is what a test or a library caller wants.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Wait:
+    """How a wait for the device is going, for whoever draws the progress.
+
+    ``typical_s`` is how long this normally takes and ``deadline_s`` when we
+    give up; showing the two apart is what stops a two-minute reboot looking
+    like a fifteen-minute hang.
+    """
+
+    elapsed_s: float
+    deadline_s: float
+    typical_s: float
+    label: str  # what the device last answered, in words
+    poll: int  # how many times we have asked
+    next_poll_in_s: float | None  # None while a request is in flight
+
+
+class Reporter:
+    """Somewhere to report progress to.  This one reports it nowhere."""
+
+    def step(self, message: str) -> None:
+        """Announce a new phase of the operation."""
+
+    def detail(self, message: str) -> None:
+        """Show a detail from inside the current phase."""
+
+    def warn(self, message: str) -> None:
+        """Flag something that went wrong but does not stop the operation."""
+
+    def sending(self, sent: int, total: int, elapsed_s: float, label: str = "") -> None:
+        """Note that ``sent`` of ``total`` units of the current transfer have moved.
+
+        ``label`` names the transfer for whoever draws it -- the file, or
+        what it is doing to it -- because an operation can have more than
+        one: a firmware upgrade downloads an image before it uploads it, and
+        a bar that says "Uploading" through both is lying for the first half.
+        """
+
+    def waiting(self, wait: Wait) -> None:
+        """Redraw whatever shows a wait in progress; called about once a second."""
+
+    def polled(self, wait: Wait) -> None:
+        """Record that a poll came back; ``wait.label`` says what it meant."""
+
+
+SILENT = Reporter()
+
+__all__ = ["SILENT", "Reporter", "Wait"]

devicectl/testing.py

@@ -0,0 +1,199 @@
+"""Check that a fake can be handed to code that expects the real thing.
+
+Every one of these programs tests its commands against a fake device, and
+nothing has ever held the fake to the shape of the thing it stands in for.
+A fake drifts silently: the client grows a parameter, the fake does not,
+and the tests go on passing against a device that cannot exist.  Worse,
+they pass against a *call* that cannot be made -- the fake answers
+``login()`` while every real caller says ``login(timeout=...)``.
+
+:func:`stands_in_for` compares the two by signature, and says what would
+break.  It is not a type checker: it looks only at how each method may be
+called, which is the part a fake gets wrong.
+
+``real`` may be a class or a :class:`~typing.Protocol`, and the difference
+is how strict the answer is.  A class is a menu -- a fake implements the
+handful of methods its tests reach, and only those are compared.  A
+protocol is a contract -- every member of it must be there.
+"""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Container, Iterator
+from typing import Any
+
+__all__ = ["assert_stands_in_for", "stands_in_for"]
+
+_POSITIONAL = (
+    inspect.Parameter.POSITIONAL_ONLY,
+    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+)
+
+
+def _members(cls: type, ignore: Container[str]) -> Iterator[tuple[str, Any]]:
+    """Walk the public callables ``cls`` itself defines, in definition order."""
+    for name, value in vars(cls).items():
+        if name.startswith("_") or name in ignore:
+            continue
+        if isinstance(value, (staticmethod, classmethod)):
+            value = value.__func__
+        if callable(value):
+            yield name, value
+
+
+def _is_protocol(cls: type) -> bool:
+    """Whether ``cls`` is a Protocol rather than an ordinary class."""
+    return bool(getattr(cls, "_is_protocol", False))
+
+
+def _protocol_names(cls: type, ignore: Container[str]) -> list[str]:
+    """List every member a protocol asks an implementation for."""
+    names = set(getattr(cls, "__protocol_attrs__", ()))
+    if not names:  # before 3.12 the set is not kept on the class
+        names = {n for n in vars(cls) if not n.startswith("_")}
+        names |= {
+            n for n in getattr(cls, "__annotations__", {}) if not n.startswith("_")
+        }
+    return sorted(n for n in names if n not in ignore)
+
+
+def _params(fn: Any) -> list[inspect.Parameter]:
+    """``fn``'s parameters, without the one the instance fills in."""
+    try:
+        found = list(inspect.signature(fn).parameters.values())
+    except (TypeError, ValueError):  # a C function with no signature to read
+        return []
+    return found[1:] if found and found[0].name in ("self", "cls") else found
+
+
+def _absorbs(params: list[inspect.Parameter]) -> tuple[bool, bool]:
+    """Whether these parameters end in ``*args``, and whether in ``**kwargs``."""
+    kinds = {p.kind for p in params}
+    return (
+        inspect.Parameter.VAR_POSITIONAL in kinds,
+        inspect.Parameter.VAR_KEYWORD in kinds,
+    )
+
+
+_EMPTY = inspect.Parameter.empty
+
+
+def _wrong_position(
+    want: inspect.Parameter,
+    here: inspect.Parameter | None,
+    at: int,
+    absorbs: tuple[bool, bool],
+) -> str | None:
+    """Say why ``want`` could not be passed by position, or nothing."""
+    if here is None or here.kind not in _POSITIONAL:
+        return None if all(absorbs) else f"takes no {want.name} in position {at}"
+    # A positional-only parameter is passed by position alone, so the name
+    # the stand-in gives it is its own business.
+    if want.kind is not inspect.Parameter.POSITIONAL_ONLY and here.name != want.name:
+        return f"calls {want.name} '{here.name}'"
+    return None
+
+
+def _wrong_keyword(
+    want: inspect.Parameter,
+    here: inspect.Parameter | None,
+    star_kwargs: bool,
+) -> str | None:
+    """Say why ``want`` could not be passed by name, or nothing."""
+    if here is not None and here.kind is not inspect.Parameter.POSITIONAL_ONLY:
+        return None
+    return None if star_kwargs else f"does not take {want.name}="
+
+
+def _missing_star(want: inspect.Parameter, absorbs: tuple[bool, bool]) -> str | None:
+    """Say why a ``*args`` or ``**kwargs`` of ``want`` has nowhere to go."""
+    star_args, star_kwargs = absorbs
+    if want.kind is inspect.Parameter.VAR_POSITIONAL and not star_args:
+        return f"does not take *{want.name}"
+    if want.kind is inspect.Parameter.VAR_KEYWORD and not star_kwargs:
+        return f"does not take **{want.name}"
+    return None
+
+
+def _call_differences(real: Any, fake: Any) -> list[str]:
+    """List every way ``real`` may be called that ``fake`` would not survive."""
+    wanted = _params(real)
+    given = _params(fake)
+    absorbs = _absorbs(given)
+    by_name = {p.name: p for p in given}
+    positional = [p for p in given if p.kind in _POSITIONAL]
+    problems: list[str] = []
+
+    at = 0
+    for want in wanted:
+        if want.kind in (
+            inspect.Parameter.VAR_POSITIONAL,
+            inspect.Parameter.VAR_KEYWORD,
+        ):
+            problems += filter(None, [_missing_star(want, absorbs)])
+            continue
+        if want.kind in _POSITIONAL:
+            here = positional[at] if at < len(positional) else None
+            at += 1
+            wrong = _wrong_position(want, here, at, absorbs)
+        else:
+            here = by_name.get(want.name)
+            wrong = _wrong_keyword(want, here, absorbs[1])
+        if wrong:
+            problems.append(wrong)
+        elif want.default is not _EMPTY and here is not None and here.default is _EMPTY:
+            problems.append(f"insists on {want.name}, which is optional")
+
+    asked = {p.name for p in wanted}
+    spares = positional[at:] + [
+        p for p in given if p.kind is inspect.Parameter.KEYWORD_ONLY
+    ]
+    for spare in spares:
+        if spare.default is _EMPTY and spare.name not in asked:
+            problems.append(f"insists on {spare.name}, which no caller passes")
+    return problems
+
+
+def stands_in_for(real: type, fake: type, *, ignore: Container[str] = ()) -> list[str]:
+    """List what stops ``fake`` being handed to code that expects ``real``.
+
+    Returns a sentence per problem, and an empty list when there is none.
+    Names in ``ignore`` are skipped on both sides, which is how a fake keeps
+    a helper of its own that the real thing has no reason to grow.
+    """
+    complaints = []
+    # A protocol is a lower bound, so a stand-in for one may do more than it
+    # asks; a class is the whole menu, so anything extra is a call nothing
+    # makes.  `serial.Serial` is the case that proves it: it satisfies every
+    # serial protocol worth writing and has thirty methods besides.
+    contract = _protocol_names(real, ignore) if _is_protocol(real) else None
+    for name, method in _members(fake, ignore):
+        if contract is not None and name not in contract:
+            continue
+        against = getattr(real, name, None)
+        if against is None:
+            complaints.append(
+                f"{fake.__name__}.{name} answers a call {real.__name__} does not take"
+            )
+            continue
+        for problem in _call_differences(against, method):
+            complaints.append(f"{fake.__name__}.{name} {problem}")
+
+    if contract is not None:
+        for name in contract:
+            if not hasattr(fake, name):
+                complaints.append(f"{fake.__name__} has no {name}")
+    return complaints
+
+
+def assert_stands_in_for(
+    real: type, fake: type, *, ignore: Container[str] = ()
+) -> None:
+    """Fail the test, readably, if ``fake`` could not stand in for ``real``."""
+    problems = stands_in_for(real, fake, ignore=ignore)
+    if problems:
+        raise AssertionError(
+            f"{fake.__name__} cannot stand in for {real.__name__}:\n  "
+            + "\n  ".join(problems)
+        )

devicectl/trace.py

@@ -0,0 +1,333 @@
+"""A recording of what actually went over the wire, and the report it makes.
+
+When a device refuses something, the sentence a program can show is the one
+its protocol layer raised -- "no/short response", "bad CRC", "modbus
+exception 2".  That is enough to know it failed and never enough to know
+why: the answer is in the bytes, in what was asked immediately before, and
+in the gaps between them, none of which anybody is holding by the time the
+message reaches a browser.
+
+So: a ring buffer that can be switched on from the page, a hook the
+protocol layer already has for ``--trace`` to feed it, and a plain-text
+report to download and send to somebody.  It is off until asked for -- a
+few hundred frames a minute of a device that is working is nothing anyone
+wants to keep -- and bounded when it is on, because the thing being
+debugged is often a program left running overnight.
+
+An entry need not be a frame.  Half of a fault report is what somebody
+asked for, so the same recording takes :meth:`Recorder.called` -- the
+request a page made and the body it sent -- and prints it between the
+frames it caused.
+
+Nothing here knows a protocol.  An entry is a direction, some bytes and a
+note, and what those bytes *mean* is a ``decode`` function the program
+supplies: :func:`render` calls it per frame and prints whatever it returns
+under the hex.  A program with no decoder gets the hex, which is still the
+thing that was missing.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable, Sequence
+
+# How many entries a recording keeps before the oldest fall off.  A Modbus
+# beat is two frames every three seconds, so this is a few hours of an idle
+# page and a good many minutes of somebody actively poking at a device --
+# and about four megabytes of report at the worst, which is still a file an
+# email will take.
+DEFAULT_LIMIT = 20000
+
+# The directions an entry can have.  They are two characters wide on
+# purpose: the report puts them in a column.
+TX = "TX"
+RX = "RX"
+NOTE = "--"
+UI = "UI"
+
+# How many bytes of a frame go on one line of the report.
+HEX_WIDTH = 16
+
+
+@dataclass(frozen=True)
+class Entry:
+    """One thing that happened on the link, as the report will print it."""
+
+    at: float
+    """When, as a wall clock time -- the report is read against a log."""
+
+    direction: str
+    """:data:`TX`, :data:`RX`, :data:`UI` for something the page asked for, or
+    :data:`NOTE` for anything else that is not a frame."""
+
+    data: bytes = b""
+    """The bytes themselves.  Empty for a note, and for a read that timed out."""
+
+    note: str = ""
+    """What the program was doing, in its own words, or what a note says."""
+
+    detail: str = ""
+    """Text printed under the entry where the hex would go: a request body, a
+    decoded structure, anything that is already words rather than bytes."""
+
+
+class Recorder:
+    """A bounded, thread-safe recording of a link, off until it is started.
+
+    The protocol layer calls :meth:`add` from whichever thread owns the
+    link; the page asks for :meth:`state` and :func:`render` from a request
+    thread.  Hence the lock, and hence :meth:`add` doing as little as it
+    can while holding it.
+    """
+
+    def __init__(self, limit: int = DEFAULT_LIMIT) -> None:
+        """Make a recorder that keeps at most ``limit`` entries."""
+        self.limit = limit
+        self._lock = threading.Lock()
+        self._entries: deque[Entry] = deque(maxlen=limit)
+        self._on = False
+        self._started: float | None = None
+        self._dropped = 0
+        self._automatic = False
+        self._stopped: float | None = None
+
+    # --- switching it on and off --------------------------------------------------------
+
+    @property
+    def on(self) -> bool:
+        """Whether anything handed to :meth:`add` is being kept."""
+        return self._on
+
+    def start(self, automatic: bool = False) -> None:
+        """Begin recording, from empty.
+
+        From empty rather than from wherever the last one stopped: a
+        recording is made to reproduce one thing, and frames from an hour
+        ago are noise somebody then has to scroll past.
+
+        ``automatic`` is for a recording nobody asked for by hand -- one a
+        failure started (see the page's trace.js).  It is kept so the page
+        can say so, and so that turning that behaviour off can stop the
+        recording it made without stopping one somebody started themselves.
+        """
+        with self._lock:
+            self._entries.clear()
+            self._dropped = 0
+            self._on = True
+            self._started = time.time()
+            self._stopped = None
+            self._automatic = automatic
+        self.say("recording started" + (" after a failure" if automatic else ""))
+
+    def stop(self) -> None:
+        """Stop recording, keeping what was recorded.
+
+        Kept deliberately: the ordinary way this is used is reproduce the
+        fault, stop, download.  A stop that emptied the buffer would throw
+        away the recording at the moment it became worth having.
+        """
+        if not self._on:
+            return
+        self.say("recording stopped")
+        with self._lock:
+            self._on = False
+            self._automatic = False
+            self._stopped = time.time()
+
+    def clear(self) -> None:
+        """Throw away what was recorded, without changing whether it is on."""
+        with self._lock:
+            self._entries.clear()
+            self._dropped = 0
+            self._started = time.time() if self._on else None
+
+    # --- recording ----------------------------------------------------------------------
+
+    def add(
+        self, direction: str, data: bytes, note: str = "", detail: str = ""
+    ) -> None:
+        """Record one frame.  Does nothing at all while the recorder is off."""
+        if not self._on:
+            return
+        with self._lock:
+            if len(self._entries) == self.limit:
+                self._dropped += 1
+            self._entries.append(
+                Entry(
+                    at=time.time(),
+                    direction=direction,
+                    data=bytes(data),
+                    note=note,
+                    detail=detail,
+                )
+            )
+
+    def say(self, note: str) -> None:
+        """Record something that is not a frame: an error, a phase, a choice.
+
+        This is the half a byte log cannot carry.  "no reply" is a silence,
+        and a silence looks exactly like the end of the recording unless
+        something writes it down.
+        """
+        self.add(NOTE, b"", note)
+
+    def called(self, note: str, detail: str = "") -> None:
+        """Record something somebody asked the program to do.
+
+        A recording of a wire answers what the program said; it never
+        answers why it said it.  Half of a fault report is which button was
+        pressed and what was in the box beside it -- which, for a program
+        driven by a page, is the request the page made and the body it sent.
+        Those go in here, between the frames they caused.
+        """
+        self.add(UI, b"", note, detail=detail)
+
+    def hook(
+        self, note: Callable[[], str] | None = None
+    ) -> Callable[[str, bytes], None]:
+        """Return a ``log(direction, data)`` of the shape protocol layers take.
+
+        ``note`` is asked, per frame, what the program is doing right now --
+        which is the one thing the bytes cannot say and the first thing
+        anybody reading the report wants.
+        """
+        return lambda direction, data: self.add(
+            direction, data, note() if note is not None else ""
+        )
+
+    # --- what the page shows ------------------------------------------------------------
+
+    def entries(self) -> list[Entry]:
+        """Everything kept, oldest first."""
+        with self._lock:
+            return list(self._entries)
+
+    def state(self) -> dict[str, Any]:
+        """Describe the recording as the page draws it: on, how much, since when."""
+        with self._lock:
+            return {
+                "on": self._on,
+                "automatic": self._on and self._automatic,
+                "frames": len(self._entries),
+                "dropped": self._dropped,
+                "since": self._started,
+                # When it stopped, so a stopped recording says how long it
+                # ran rather than how long ago it started.
+                "until": None if self._on else self._stopped,
+                "limit": self.limit,
+                "bytes": sum(len(e.data) + len(e.detail) for e in self._entries),
+            }
+
+
+def hexdump(data: bytes, width: int = HEX_WIDTH) -> list[str]:
+    """Split ``data`` into lines of space-separated hex, ``width`` bytes each."""
+    return [data[at : at + width].hex(" ") for at in range(0, len(data), width)]
+
+
+def render(
+    recorder: Recorder,
+    *,
+    title: str,
+    facts: Sequence[tuple[str, Any]] = (),
+    decode: Callable[[str, bytes], str] | None = None,
+    preamble: str = "",
+) -> str:
+    """Render a recording as the plain-text report somebody downloads.
+
+    ``facts`` is what the report has to say for itself before the frames --
+    the program's version, the port, the speed, the device -- because a
+    trace read a week later by somebody else answers nothing without them.
+    ``decode`` turns one frame into a sentence; ``preamble`` is the program's
+    own paragraph about how to read what follows.
+    """
+    entries = recorder.entries()
+    state = recorder.state()
+    lines = [title, "=" * len(title), ""]
+    rows: list[tuple[str, str]] = [(str(k), _fact(v)) for k, v in facts]
+    rows.append(("recorded", _window(entries)))
+    rows.append(("frames", _count(state)))
+    pad = max((len(k) for k, _ in rows), default=0)
+    lines += [f"{k.ljust(pad)}   {v}" for k, v in rows]
+    if preamble:
+        lines += ["", *preamble.strip().splitlines()]
+    lines += ["", "-" * 72, ""]
+    if not entries:
+        lines.append("Nothing was recorded.")
+        return "\n".join(lines) + "\n"
+    previous: float | None = None
+    for entry in entries:
+        lines += _frame(entry, previous, decode)
+        previous = entry.at
+    return "\n".join(lines) + "\n"
+
+
+def _frame(
+    entry: Entry, previous: float | None, decode: Callable[[str, bytes], str] | None
+) -> list[str]:
+    """One entry, as the two or more lines the report prints it on."""
+    gap = "" if previous is None else f"  (+{(entry.at - previous) * 1000:.0f} ms)"
+    head = f"{_clock(entry.at)}  {entry.direction}{gap}"
+    if entry.note:
+        head += f"  {entry.note}"
+    lines = [head]
+    indent = " " * 14
+    lines += [indent + line for line in hexdump(entry.data)]
+    lines += [indent + line for line in entry.detail.splitlines()]
+    if entry.direction == RX and not entry.data:
+        lines.append(indent + "(nothing)")
+    said = decode(entry.direction, entry.data) if decode and entry.data else ""
+    if said:
+        lines.append(indent + said)
+    return lines
+
+
+def _clock(at: float) -> str:
+    """Render a wall clock time with milliseconds, the scale a frame lives on."""
+    return (
+        time.strftime("%H:%M:%S", time.localtime(at)) + f".{int(at * 1000) % 1000:03d}"
+    )
+
+
+def _fact(value: Any) -> str:
+    """Render one header value, spelling a missing one out rather than blank."""
+    if value is None or value == "":
+        return "(not known)"
+    if isinstance(value, (list, tuple)):
+        return ", ".join(str(v) for v in value) or "(none)"
+    return str(value)
+
+
+def _window(entries: Iterable[Entry]) -> str:
+    """When the recording starts and stops, and how long it ran."""
+    kept = list(entries)
+    if not kept:
+        return "(nothing)"
+    first, last = kept[0].at, kept[-1].at
+    day = time.strftime("%Y-%m-%d", time.localtime(first))
+    return f"{day} {_clock(first)} .. {_clock(last)}  ({last - first:.1f} s)"
+
+
+def _count(state: dict[str, Any]) -> str:
+    """How many frames were kept, and how many fell off the front."""
+    said = f"{state['frames']} kept, {state['bytes']} bytes"
+    dropped = int(state["dropped"] or 0)
+    if dropped:
+        said += f", {dropped} older one(s) dropped (the buffer holds {state['limit']})"
+    return said
+
+
+__all__ = [
+    "DEFAULT_LIMIT",
+    "HEX_WIDTH",
+    "NOTE",
+    "RX",
+    "TX",
+    "UI",
+    "Entry",
+    "Recorder",
+    "hexdump",
+    "render",
+]

devicectl/web/__init__.py

@@ -0,0 +1 @@
+"""The browser half: the event stream, the HTTP primitives, the server."""