qso-graph-sim 0.1.0__py3-none-any.whl

qso_graph_sim/__init__.py

@@ -0,0 +1,15 @@
+"""qso-graph-sim: replays what ham radio programs send on the network, for testing."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import Final
+
+try:
+    _pkg_version = version("qso-graph-sim")
+except PackageNotFoundError:  # source tree without dist metadata
+    _pkg_version = "0.0.0-dev"
+
+# Read from the installed distribution, so pyproject.toml is the only place
+# the version is written.
+__version__: Final[str] = _pkg_version

qso_graph_sim/alltxt.py

@@ -0,0 +1,103 @@
+"""Reading WSJT-X's ALL.TXT, the log of every decode it has made.
+
+One line per decode, in the format WSJT-X has written since 2.x::
+
+    260407_233915    14.074 Rx FT8    -12  0.2 1234 CQ K7ABC DN13
+
+date_time (UTC), dial frequency in MHz, Rx or Tx, mode, SNR in dB, DT in
+seconds, audio offset in Hz, then the message.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+_LINE = re.compile(
+    r"^(\d{6}_\d{6})\s+(\d+(?:\.\d+)?)\s+(Rx|Tx)\s+(\S+)\s+(-?\d+)\s+(-?\d+(?:\.\d+)?)"
+    r"\s+(\d+)\s+(.+?)\s*$"
+)
+# WSJT-X marks a decode it has low confidence in with a trailing "?"; it is
+# not part of the message that was sent.
+_LOW_CONFIDENCE = re.compile(r"\s\?$")
+
+
+@dataclass(frozen=True)
+class Line:
+    stamp: str          # as written: YYMMDD_HHMMSS
+    utc: datetime
+    dial_hz: int
+    direction: str      # "Rx" or "Tx"
+    mode: str           # the mode's name, e.g. "FT8"
+    snr: int
+    dt: float
+    df: int
+    message: str
+    low_confidence: bool
+
+
+def parse_line(text: str) -> Line | None:
+    """One ALL.TXT line, or None if it is not one."""
+    m = _LINE.match(text)
+    if not m:
+        return None
+    stamp, mhz, direction, mode, snr, dt, df, message = m.groups()
+    try:
+        utc = datetime.strptime(stamp, "%y%m%d_%H%M%S").replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+    low = bool(_LOW_CONFIDENCE.search(message))
+    return Line(
+        stamp=stamp,
+        utc=utc,
+        dial_hz=round(float(mhz) * 1_000_000),
+        direction=direction,
+        mode=mode,
+        snr=int(snr),
+        dt=float(dt),
+        df=int(df),
+        message=_LOW_CONFIDENCE.sub("", message) if low else message,
+        low_confidence=low,
+    )
+
+
+@dataclass
+class Cycle:
+    """The decodes of one T/R period on one dial frequency."""
+
+    stamp: str
+    dial_hz: int
+    mode: str
+    decodes: list[Line] = field(default_factory=list)
+
+
+@dataclass
+class Log:
+    cycles: list[Cycle]
+    skipped: int  # Tx lines and lines that are not decodes
+
+    @property
+    def decodes(self) -> int:
+        return sum(len(c.decodes) for c in self.cycles)
+
+
+def read(text: str, start: str = "") -> Log:
+    """Group received decodes into cycles, in file order, from ``start`` on."""
+    cycles: list[Cycle] = []
+    skipped = 0
+    for raw in text.splitlines():
+        if not raw.strip():
+            continue
+        line = parse_line(raw)
+        if line is None or line.direction != "Rx":
+            skipped += 1
+            continue
+        if start and line.stamp < start:
+            continue
+        last = cycles[-1] if cycles else None
+        if last and last.stamp == line.stamp and last.dial_hz == line.dial_hz:
+            last.decodes.append(line)
+        else:
+            cycles.append(Cycle(line.stamp, line.dial_hz, line.mode, [line]))
+    return Log(cycles, skipped)

qso_graph_sim/cli.py

@@ -0,0 +1,138 @@
+"""The qso-graph-sim command."""
+
+from __future__ import annotations
+
+import argparse
+import ipaddress
+import re
+import signal
+import socket
+import sys
+from collections.abc import Callable, Sequence
+from importlib.resources import files
+from pathlib import Path
+
+from . import __version__, alltxt
+from .player import Player, Station
+
+SAMPLE = "ALL-sample.TXT"
+_STAMP = re.compile(r"^\d{6}_\d{6}$")
+_CALL = re.compile(r"^[A-Z0-9/]{0,13}$")
+_GRID = re.compile(r"^([A-R]{2}\d{2}([A-X]{2})?)?$")
+
+
+def target(text: str) -> tuple[str, int]:
+    """IP:PORT, or [IPv6]:PORT. An address, not a name: nothing is looked up."""
+    m = re.match(r"^\[?([^\]]+?)\]?:(\d{1,5})$", text)
+    if not m:
+        raise argparse.ArgumentTypeError(
+            "use IP:PORT, the address QSO Graph Desktop listens on"
+        )
+    host, port = m.group(1), int(m.group(2))
+    try:
+        ipaddress.ip_address(host)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"{host} is not an IP address") from None
+    if not 0 < port < 65536:
+        raise argparse.ArgumentTypeError(f"{port} is not a port")
+    return host, port
+
+
+def _matching(
+    pattern: re.Pattern[str], what: str, upper: bool = False
+) -> Callable[[str], str]:
+    def check(text: str) -> str:
+        if text == "":
+            return text  # the default: not given
+        value = text.upper() if upper else text
+        if not pattern.match(value):
+            raise argparse.ArgumentTypeError(f"{text!r} is not {what}")
+        return value
+    return check
+
+
+def _speed(text: str) -> float:
+    try:
+        v = float(text)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"{text!r} is not a number") from None
+    if not 0 < v <= 1000:
+        raise argparse.ArgumentTypeError("speed is more than 0 and at most 1000")
+    return v
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="qso-graph-sim",
+        description=(
+            "Replays what a ham radio program sends on the network, from its own log, "
+            "so a receiver can be tested without a radio."
+        ),
+    )
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    app = p.add_mutually_exclusive_group(required=True)
+    app.add_argument("--wsjtx", action="store_true",
+                     help="WSJT-X: play an ALL.TXT as its UDP messages")
+    p.add_argument("--to", type=target, required=True, metavar="IP:PORT",
+                   help="where to send: the receiver's address and port (WSJT-X uses 2237)")
+    p.add_argument("--file", type=Path, metavar="PATH",
+                   help="the log to play (default: a sample of 20 m FT8, 120 decodes)")
+    p.add_argument("--from", dest="start", type=_matching(_STAMP, "YYMMDD_HHMMSS"),
+                   default="", metavar="YYMMDD_HHMMSS", help="start at this time in the log")
+    p.add_argument("--id", default="WSJT-X", metavar="NAME",
+                   type=_matching(re.compile(r"^.{1,64}$"), "an Id"),
+                   help="the instance name to send as (WSJT-X's default is WSJT-X)")
+    p.add_argument("--call", default="", type=_matching(_CALL, "a callsign", upper=True),
+                   help="your callsign, sent in Status")
+    p.add_argument("--grid", default="", type=_matching(_GRID, "a 4- or 6-character grid"),
+                   help="your grid, sent in Status")
+    p.add_argument("--speed", type=_speed, default=1.0, metavar="N",
+                   help="play faster than real time, for testing (default 1)")
+    p.add_argument("--loop", action="store_true", help="start again at the end")
+    return p
+
+
+def _read(path: Path | None) -> tuple[str, str]:
+    if path is None:
+        sample = files("qso_graph_sim").joinpath("samples", SAMPLE)
+        return sample.read_text("utf-8"), "the sample"
+    return path.read_text("utf-8", errors="replace"), str(path)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        text, name = _read(args.file)
+    except OSError as e:
+        print(f"qso-graph-sim: cannot read {args.file}: {e.strerror}", file=sys.stderr)
+        return 1
+    log = alltxt.read(text, args.start)
+    if not log.cycles:
+        print(f"qso-graph-sim: no received decodes in {name}"
+              + (f" from {args.start}" if args.start else ""), file=sys.stderr)
+        return 1
+    print(f"{len(log.cycles)} cycles, {log.decodes} decodes from {name}"
+          + (f" ({log.skipped} lines skipped: Tx or not a decode)" if log.skipped else ""))
+    host, port = args.to
+    family = socket.AF_INET6 if ipaddress.ip_address(host).version == 6 else socket.AF_INET
+    with socket.socket(family, socket.SOCK_DGRAM) as sock:
+        print(f"sending to {host}:{port} as {args.id}; Ctrl+C to stop")
+        player = Player(
+            sock=sock, target=(host, port), log=log,
+            station=Station(sender=args.id, call=args.call, grid=args.grid),
+            speed=args.speed, loop=args.loop,
+        )
+        signal.signal(signal.SIGTERM, lambda *_: player.stop())
+        try:
+            player.run()
+        except KeyboardInterrupt:
+            player.stop()
+        except OSError as e:
+            print(f"qso-graph-sim: cannot send to {host}:{port}: {e.strerror}",
+                  file=sys.stderr)
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

qso_graph_sim/player.py

@@ -0,0 +1,148 @@
+"""Playing an ALL.TXT back as WSJT-X would have sent it.
+
+One cycle every 15 seconds, at the real pace unless sped up for a test. Per
+cycle: a Heartbeat (WSJT-X sends one every 15 seconds), a Status as decoding
+starts, the cycle's Decodes, and a Status as it ends. The Status carries the
+dial frequency, so a band change in the log shows there; WSJT-X does not send
+Clear for a band change, because its Band Activity window keeps the earlier
+decodes, so neither does this. On the way out it sends Clear then Close, as
+WSJT-X does when it shuts down normally.
+
+Decodes are stamped with the cycle they are played in, not the one they were
+logged in, so a receiver sees a live band rather than one from last April.
+
+It answers Replay the way WSJT-X does: every decode still in its window,
+marked not new, then a Status. Datagrams from anywhere but the address it was
+pointed at are ignored, and so is anything addressed to a different Id.
+"""
+
+from __future__ import annotations
+
+import select
+import socket
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field, replace
+
+from . import wsjtx
+from .alltxt import Cycle, Log
+
+CYCLE_SECONDS = 15
+
+
+@dataclass
+class Station:
+    sender: str = "WSJT-X"
+    call: str = ""
+    grid: str = ""
+
+
+@dataclass
+class Player:
+    sock: socket.socket
+    target: tuple[str, int]
+    log: Log
+    station: Station = field(default_factory=Station)
+    speed: float = 1.0
+    loop: bool = False
+    say: Callable[[str], None] = print
+    clock: Callable[[], float] = time.time
+    _window: list[wsjtx.Decode] = field(default_factory=list, init=False)
+    _status: wsjtx.Status | None = field(default=None, init=False)
+    _stop: bool = field(default=False, init=False)
+
+    def stop(self) -> None:
+        self._stop = True
+
+    def _send(self, data: bytes) -> None:
+        self.sock.sendto(data, self.target)
+
+    def _send_status(self) -> None:
+        if self._status is not None:
+            self._send(wsjtx.status(self.station.sender, self._status))
+
+    # ------------------------------------------------------------ incoming
+
+    def accepts(self, address: str) -> bool:
+        """Only the receiver this was pointed at may talk to it."""
+        return address.removeprefix("::ffff:") == self.target[0]
+
+    def _handle(self, data: bytes, address: str) -> None:
+        if not self.accepts(address):
+            return
+        try:
+            msg = wsjtx.parse(data)
+        except ValueError:
+            return
+        if msg.sender != self.station.sender:
+            return
+        if msg.kind == wsjtx.MessageType.REPLAY:
+            self.say(f"replay asked for: sending {len(self._window)} decodes")
+            for d in self._window:
+                self._send(wsjtx.decode(self.station.sender, replace(d, is_new=False)))
+            self._send_status()
+        # Reply, Halt Tx, Free Text, Close and the rest would act on a real
+        # WSJT-X. A monitor never sends them, so there is nothing to do.
+
+    def _wait(self, until: float) -> None:
+        """Sleep until ``until`` (real time), answering anything that arrives."""
+        while not self._stop:
+            left = until - time.monotonic()
+            if left <= 0:
+                return
+            ready, _, _ = select.select([self.sock], [], [], min(left, 0.5))
+            if ready:
+                try:
+                    data, (address, *_rest) = self.sock.recvfrom(65_535)
+                except OSError:
+                    continue
+                self._handle(data, address)
+
+    # ------------------------------------------------------------ playback
+
+    def _play(self, cycle: Cycle, played_at: float) -> None:
+        ms_of_day = int((played_at % 86_400) * 1000)
+        self._status = wsjtx.Status(
+            dial_hz=cycle.dial_hz, mode=cycle.mode, de_call=self.station.call,
+            de_grid=self.station.grid, decoding=True,
+        )
+        self._send(wsjtx.heartbeat(self.station.sender))
+        self._send_status()
+        for line in cycle.decodes:
+            d = wsjtx.Decode(
+                is_new=True, ms_of_day=ms_of_day, snr=line.snr, dt=line.dt, df=line.df,
+                mode=wsjtx.mode_character(line.mode), message=line.message,
+                low_confidence=line.low_confidence,
+            )
+            self._send(wsjtx.decode(self.station.sender, d))
+            self._window.append(d)
+        self._status = replace(self._status, decoding=False)
+        self._send_status()
+
+    def run(self) -> None:
+        if not self.log.cycles:
+            raise ValueError("nothing to play: no received decodes")
+        # The first cycle is stamped with the T/R period now under way; each
+        # one after it, 15 seconds later.
+        first = self.clock() // CYCLE_SECONDS * CYCLE_SECONDS
+        started = time.monotonic()
+        n = 0
+        try:
+            while not self._stop:
+                for cycle in self.log.cycles:
+                    if self._stop:
+                        break
+                    played_at = first + n * CYCLE_SECONDS
+                    self._play(cycle, played_at)
+                    stamp = time.strftime("%H:%M:%S", time.gmtime(played_at))
+                    self.say(
+                        f"{stamp}  {cycle.dial_hz / 1e6:.3f} {cycle.mode}  "
+                        f"{len(cycle.decodes):2d} decodes  (logged {cycle.stamp})"
+                    )
+                    n += 1
+                    self._wait(started + n * CYCLE_SECONDS / self.speed)
+                if not self.loop:
+                    break
+        finally:
+            self._send(wsjtx.clear(self.station.sender))
+            self._send(wsjtx.close(self.station.sender))

qso_graph_sim/samples/ALL-sample.TXT

@@ -0,0 +1,120 @@
+260407_233830    14.074 Rx FT8      0  0.3 2544 N5EMM KE0QEQ EN04
+260407_233830    14.074 Rx FT8     -4  0.2 1662 CQ N5VAN DN91
+260407_233830    14.074 Rx FT8     -7  0.3 1498 CQ KW7E DM33
+260407_233830    14.074 Rx FT8      1  0.2 1940 PY2VZ KJ4KFJ 73
+260407_233830    14.074 Rx FT8    -13  0.5 2221 CQ N8RAF EN90
+260407_233830    14.074 Rx FT8    -11  0.3 1085 KB2KBC KY4JDC +21
+260407_233830    14.074 Rx FT8    -18  0.4 1851 PP5TG KD8VAX -17
+260407_233830    14.074 Rx FT8    -13  0.3  913 CQ NN8M EM79
+260407_233830    14.074 Rx FT8    -15  0.3 1149 CQ PP2BO GH61
+260407_233830    14.074 Rx FT8    -14  0.3  500 KC0IUY N8PFK EM80
+260407_233830    14.074 Rx FT8    -22  0.2 1343 PY2MM AE1JR 73
+260407_233830    14.074 Rx FT8    -14  0.3 2230 LW5DR AK8A RR73
+260407_233830    14.074 Rx FT8    -19  0.4 1513 N5EMM KS5X EM15
+260407_233830    14.074 Rx FT8    -15  0.5  897 VA2PM W6RJR DM13
+260407_233830    14.074 Rx FT8    -17  0.3 2550 N5EMM K8TJM EN91
+260407_233845    14.074 Rx FT8     10  1.1 1003 CX3JY N6PE DM13
+260407_233845    14.074 Rx FT8      1  0.3 2221 N8RAF KI6BWO DM04
+260407_233845    14.074 Rx FT8      3  0.6  497 KD2VRL W6DAD DM33
+260407_233845    14.074 Rx FT8      4  1.2 1237 CQ NL7D DM42
+260407_233845    14.074 Rx FT8      3  0.2 1940 K6VVK KJ4KFJ EN74
+260407_233845    14.074 Rx FT8      1  0.6 1071 AF0DB K8IG EN91
+260407_233845    14.074 Rx FT8     -8  0.3  191 TN8GD AB4OB EM70
+260407_233845    14.074 Rx FT8    -11  0.3 2006 CQ KD6UYK DM13
+260407_233845    14.074 Rx FT8    -10  0.9 1166 NM2V KA9EKJ R+15
+260407_233845    14.074 Rx FT8     -8  0.5 1895 KA3PMW KG5FDT R-19
+260407_233845    14.074 Rx FT8     -9  0.2  667 PY4STO K8RWM EN82
+260407_233845    14.074 Rx FT8    -16  0.9  254 VE3BQ KJ5W -15
+260407_233845    14.074 Rx FT8    -16  0.5 2543 K8ZI N5EMM RR73
+260407_233845    14.074 Rx FT8    -13  0.6  774 TN8GD N8IBW EM89
+260407_233845    14.074 Rx FT8    -12  0.2  400 PY4KU AD9AR EM69
+260407_233845    14.074 Rx FT8    -19  0.3 1620 KQ4SRN <W1AW/5> R+05
+260407_233845    14.074 Rx FT8    -16  0.8  754 CQ K4GBI EM70
+260407_233845    14.074 Rx FT8    -12  0.3  498 N8PFK KC0IUY +06
+260407_233845    14.074 Rx FT8    -22  0.4 1488 W7JZI V31DL EK57
+260407_233845    14.074 Rx FT8    -21  0.3 1118 K4SYT AC3PN R+23
+260407_233900    14.074 Rx FT8      5  0.4 2616 KE8VWF AD4VE DM12
+260407_233900    14.074 Rx FT8     -5  0.2 1662 CQ N5VAN DN91
+260407_233900    14.074 Rx FT8     -5  0.3 2036 KG5FDT KQ6RN -01
+260407_233900    14.074 Rx FT8    -11  0.3 1497 WB8BCU KW7E +00
+260407_233900    14.074 Rx FT8    -16  0.3 1566 WG4P PP2BO +04
+260407_233900    14.074 Rx FT8    -15  0.3 1851 CQ KD8VAX EN82
+260407_233900    14.074 Rx FT8     -7  0.3 1086 PY5AQ KY4JDC R-14
+260407_233900    14.074 Rx FT8    -18  0.4 1957 N5EMM N7VBN -15
+260407_233900    14.074 Rx FT8     -8  0.2 2886 TL8GD AA1ZZ EM16
+260407_233900    14.074 Rx FT8    -10  0.3  912 CQ NN8M EM79
+260407_233900    14.074 Rx FT8    -16  0.5 2221 CQ N8RAF EN90
+260407_233900    14.074 Rx FT8    -14  0.3  499 KC0IUY N8PFK R-11
+260407_233900    14.074 Rx FT8    -23  0.3 1725 VA3WL WD4T EM75
+260407_233900    14.074 Rx FT8    -16  0.5  898 VA2PM W6RJR DM13
+260407_233915    14.074 Rx FT8      3  1.1 1003 CX3JY N6PE DM13
+260407_233915    14.074 Rx FT8      5  0.3 2221 N8RAF KI6BWO DM04
+260407_233915    14.074 Rx FT8      4  1.3 1237 N6BBQ NL7D +00
+260407_233915    14.074 Rx FT8     -2  0.2 1940 K6VVK KJ4KFJ R-01
+260407_233915    14.074 Rx FT8      0  0.5  497 KD2VRL W6DAD DM33
+260407_233915    14.074 Rx FT8     -8  0.3  192 TN8GD AB4OB EM70
+260407_233915    14.074 Rx FT8    -14  0.3 1118 K4SYT AC3PN R+23
+260407_233915    14.074 Rx FT8    -14  0.3 2006 CQ KD6UYK DM13
+260407_233915    14.074 Rx FT8     -7  0.2  667 PY4STO K8RWM R-18
+260407_233915    14.074 Rx FT8     -5  0.6 1071 AF0DB K8IG EN91
+260407_233915    14.074 Rx FT8    -10  0.3  582 TN8GD KF8EFV -15
+260407_233915    14.074 Rx FT8    -11  0.2 1400 CQ NL8F AO63
+260407_233915    14.074 Rx FT8    -14 -0.1  857 PY4KU K8SAW -15
+260407_233915    14.074 Rx FT8    -15  0.9 1166 NM2V KA9EKJ 73
+260407_233915    14.074 Rx FT8    -14  0.2 2715 TN8GD N0STL EN35
+260407_233915    14.074 Rx FT8    -22  0.3 1620 <...> W1AW/5 73
+260407_233915    14.074 Rx FT8    -18  0.5 2544 K8TJM N5EMM -06
+260407_233915    14.074 Rx FT8    -15  0.9  254 VE3BQ KJ5W -15
+260407_233915    14.074 Rx FT8    -16  0.3 2042 KB3DHF KM7MGM DM42
+260407_233915    14.074 Rx FT8     -5  0.3  472 TN8GD W4PSX EM65
+260407_233915    14.074 Rx FT8    -13  0.4  679 W5ERX KA3E -02
+260407_233915    14.074 Rx FT8    -16  0.4 1405 TN8GD K9XJ EN63
+260407_233915    14.074 Rx FT8    -17  0.2  826 W1JKN KJ5KYB EL09
+260407_233915    14.074 Rx FT8    -19  0.5 1895 KA3PMW KG5FDT R-19
+260407_233915    14.074 Rx FT8    -12  0.3  499 N8PFK KC0IUY RR73
+260407_233915    14.074 Rx FT8    -16  0.2  401 PY4KU AD9AR EM69
+260407_233945    14.074 Rx FT8      7  1.1 1003 KD5QJQ N6PE DM13
+260407_233945    14.074 Rx FT8      5  0.3 2221 N8RAF KI6BWO R+02
+260407_233945    14.074 Rx FT8     -9  0.3  666 PY4STO K8RWM 73
+260407_233945    14.074 Rx FT8     -3  1.5 1237 N6BBQ NL7D RRR
+260407_233945    14.074 Rx FT8    -19  0.3 2007 CQ KD6UYK DM13
+260407_233945    14.074 Rx FT8    -13  0.5 2544 K8TJM N5EMM -06
+260407_233945    14.074 Rx FT8    -18  0.5 1895 KA3PMW KG5FDT R-19
+260407_233945    14.074 Rx FT8    -15 -0.1  856 KD5QJQ K8SAW +07
+260407_233945    14.074 Rx FT8    -13  0.3  472 TN8GD W4PSX EM65
+260407_233945    14.074 Rx FT8    -16  0.3  303 KB3DHF AD0AR EN41
+260407_233945    14.074 Rx FT8    -19  0.3 1118 K4SYT AC3PN 73
+260407_233945    14.074 Rx FT8    -17  0.6  774 TN8GD N8IBW EM89
+260407_233945    14.074 Rx FT8    -14  0.3 2655 CQ DX KO6IDY DM03
+260407_233945    14.074 Rx FT8    -17  0.5 1405 TN8GD K9XJ EN63
+260407_233945    14.074 Rx FT8    -18  0.2 1400 CQ NL8F AO63
+260407_233945    14.074 Rx FT8    -14  0.3  498 N8PFK KC0IUY RR73
+260407_233945    14.074 Rx FT8    -18  0.2  827 W1JKN KJ5KYB R-20
+260407_233945    14.074 Rx FT8    -16  0.3  192 TN8GD AB4OB EM70
+260407_233945    14.074 Rx FT8    -18  0.4 2602 CQ KJ5NUD EM44
+260407_234000    14.074 Rx FT8     -4  0.4 2616 KE8VWF AD4VE 73
+260407_234000    14.074 Rx FT8     -7  0.2 1662 CQ N5VAN DN91
+260407_234000    14.074 Rx FT8     -7  0.3  912 VO1DNK NN8M RR73
+260407_234000    14.074 Rx FT8     -9  0.3 1498 <W1AW/5> KW7E -11
+260407_234000    14.074 Rx FT8     -9  0.3 1086 KB2KBC KY4JDC RR73
+260407_234000    14.074 Rx FT8    -12  0.3 2036 KG5FDT KQ6RN -01
+260407_234000    14.074 Rx FT8    -22  0.4 1852 CQ KD8VAX EN82
+260407_234000    14.074 Rx FT8    -24  0.3 1725 VA3WL WD4T 73
+260407_234000    14.074 Rx FT8    -21  0.3 1451 N6PE KD5QJQ +14
+260407_234015    14.074 Rx FT8     10  1.1 1003 KD5QJQ N6PE R-02
+260407_234015    14.074 Rx FT8      7  0.3 2221 N8RAF KI6BWO 73
+260407_234015    14.074 Rx FT8    -11  0.1 1711 TN8GD K1CPT EN22
+260407_234015    14.074 Rx FT8    -17  0.3 1165 XQ5OS AD9AR EM69
+260407_234015    14.074 Rx FT8     -7  0.9  749 CQ KA9EKJ EM64
+260407_234015    14.074 Rx FT8    -10  0.4 1405 TN8GD K9XJ EN63
+260407_234015    14.074 Rx FT8    -14  0.3 2006 CQ KD6UYK DM13
+260407_234015    14.074 Rx FT8    -11  0.3  499 N8PFK KC0IUY RR73
+260407_234015    14.074 Rx FT8    -20  0.2 1940 KI7SKT KJ4KFJ 73
+260407_234015    14.074 Rx FT8    -13  0.3 2655 CQ DX KO6IDY DM03
+260407_234015    14.074 Rx FT8    -14  0.5 2714 TN8GD N0STL R-12
+260407_234015    14.074 Rx FT8    -16  0.3  303 KB3DHF AD0AR R-05
+260407_234015    14.074 Rx FT8    -16  0.5 2543 K8TJM N5EMM RR73
+260407_234015    14.074 Rx FT8    -17  0.7 2402 W5ERX W8XP EM79
+260407_234015    14.074 Rx FT8    -11  0.3  472 TN8GD W4PSX EM65
+260407_234015    14.074 Rx FT8    -17  0.2 1399 CQ NL8F AO63
+260407_234015    14.074 Rx FT8    -18  0.5  775 TN8GD N8IBW EM89