Plant phone logs in fallback dry runs
Some checks are pending
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint,free-days-interop,dependency-freshness) (push) Waiting to run
Tests / test (push) Waiting to run
Tests / free-days-interop (push) Waiting to run
release-apk / release (APK) (push) Waiting to run
repo-contract / repo contract (push) Waiting to run

_fallback --dry-run --published FILE reads the phone's logs from a JSON
list of [device_id, alarm.json] pairs instead of Firebase, morning and
evening alike, so the bypass answers (live check C8) can be seen from
the CLI without a backend. Refused (exit 2) without --dry-run or for a
malformed file.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Krzysztof Rudnicki 2026-11-22 14:48:18 +01:00
parent 8253836612
commit 1df4f64393
6 changed files with 190 additions and 10 deletions

View File

@ -77,6 +77,9 @@ a minute is recorded once (both activities run the launch check).
than the bypass, which the phone also pushes at once. Free and sick days
and an escape stand it down. The tick reads the phone until `A + 4 h`
(`BYPASS_WATCH`); the fallback timer ticks 04:00-11:59 (and 21:xx, below).
To see these answers without a backend, `_fallback --dry-run --at <instant>
--published <file>` reads the phone's logs from a JSON list of
`[device_id, alarm.json]` pairs instead of Firebase (`_published_file`).
## The 21:00 notifications check

View File

@ -15,6 +15,7 @@ no session, no escape": fail toward ringing.
python -m wake_alarm._fallback --tick # what the timer runs
python -m wake_alarm._fallback --dry-run # decide now, change nothing
python -m wake_alarm._fallback --show # latch + last decision, offline
python -m wake_alarm._fallback --dry-run --published F # F replaces Firebase
"""
from __future__ import annotations
@ -50,6 +51,7 @@ from wake_alarm._fallback_policy import (
)
from wake_alarm._fallback_ring import ring
from wake_alarm._logging_setup import configure_logging
from wake_alarm._published_file import load_published
from wake_alarm._ring_probe import maybe_probe
from wake_alarm._ring_wav import SYSTEM_WAV_DIR, USER_WAV_DIR, ensure_pair
from wake_alarm._sick import alarm_stands_down
@ -215,13 +217,22 @@ def _terminate(signum: int, _frame: FrameType | None) -> None:
def main(argv: list[str] | None = None) -> int:
"""Entry point."""
parser = mode_parser("PC fallback alarm tick", "tick", "decide and act")
parser.add_argument("--published", help="with --dry-run: phone logs file")
args, now = parse_with_now(parser, argv, _now)
planted = None
if args.published is not None:
if not args.dry_run:
parser.error("--published only goes with --dry-run")
try:
planted = load_published(args.published)
except (OSError, TypeError, ValueError) as exc:
parser.error(f"--published {args.published}: {exc}")
if args.show:
sys.stdout.write(show(now))
elif args.dry_run and in_evening(now):
sys.stdout.write(evening_dry_run(now))
sys.stdout.write(evening_dry_run(now, planted))
elif args.dry_run:
seen = observe(now, sync=False)
seen = observe(now, sync=False, planted=planted)
sys.stdout.write(describe(seen, decide(seen.facts)))
else:
configure_logging(component="fallback")

View File

@ -57,8 +57,10 @@ def _tomorrow_off(now: datetime, *, sync: bool) -> str | None:
return SICK_TOMORROW if sick(tomorrow) else None
def observe_evening(now: datetime, *, sync: bool) -> EveningFacts:
"""Gather the evening's facts; Firebase only when it can change them."""
def observe_evening(
now: datetime, *, sync: bool, planted: list[tuple[str, str]] | None = None
) -> EveningFacts:
"""Gather the evening's facts; Firebase (or ``planted``) only when needed."""
day = now.date().isoformat()
facts = EveningFacts(
now=now,
@ -67,7 +69,7 @@ def observe_evening(now: datetime, *, sync: bool) -> EveningFacts:
)
if not needs_fetch(facts):
return facts
published = fetch_firebase_logs()
published = fetch_firebase_logs() if planted is None else planted
if published is None:
return replace(facts, reachable=False)
return replace(
@ -152,9 +154,9 @@ def evening_tick(now: datetime) -> Decision:
return decision
def evening_dry_run(now: datetime) -> str:
def evening_dry_run(now: datetime, planted: list[tuple[str, str]] | None = None) -> str:
"""The ``--dry-run`` report for a 21:xx instant; writes nothing."""
facts = observe_evening(now, sync=False)
facts = observe_evening(now, sync=False, planted=planted)
decision = decide(facts)
verdict = "WOULD RING" if decision.ring else "quiet"
return (

View File

@ -62,11 +62,14 @@ def _sick_today(now: datetime, *, online: bool, sync: bool) -> bool:
return alarm_stands_down(now.date())
def observe(now: datetime, *, sync: bool) -> Observation:
def observe(
now: datetime, *, sync: bool, planted: list[tuple[str, str]] | None = None
) -> Observation:
"""Gather the facts; the network only when the decision needs it.
``sync`` is False for ``--dry-run``: pulling the sick-day pool rewrites
its local file, and a dry run writes nothing.
its local file, and a dry run writes nothing. ``planted`` (``--dry-run
--published``) stands in for the Firebase fetch.
"""
day = now.date().isoformat()
latch = read_latch(day)
@ -82,7 +85,7 @@ def observe(now: datetime, *, sync: bool) -> Observation:
)
if facts.free_day or facts.sick_day or not online:
return Observation(facts)
published = fetch_firebase_logs()
published = fetch_firebase_logs() if planted is None else planted
if published is None:
return Observation(facts, reachable=False)
view = enforcement_view(published)

View File

@ -0,0 +1,42 @@
"""A planted stand-in for ``fetch_firebase_logs()``: ``--published FILE``.
Only for ``_fallback --dry-run``: the live check of the bypass ring needs
``bypass`` / ``dismissed`` events the PC can read, and there is no test
backend to put them in. The file is a JSON list of ``[device_id, alarm]``
pairs, the shape ``fetch_firebase_logs()`` returns. ``alarm`` is the
decrypted ``alarm.json`` -- an object (re-serialised here) or its raw text,
passed through as-is.
"""
from __future__ import annotations
import json
from pathlib import Path
_PAIR_LEN = 2
def _pair(entry: object) -> tuple[str, str]:
"""One ``[device_id, alarm]`` entry as ``(device_id, raw_json)``."""
if not isinstance(entry, list) or len(entry) != _PAIR_LEN:
msg = f"expected [device_id, alarm], got {entry!r}"
raise TypeError(msg)
device, alarm = entry
if not isinstance(device, str):
msg = f"device id must be a string, got {device!r}"
raise TypeError(msg)
if isinstance(alarm, str):
return device, alarm
if isinstance(alarm, dict):
return device, json.dumps(alarm)
msg = f"alarm for {device!r} must be an object or its JSON text"
raise TypeError(msg)
def load_published(path: str) -> list[tuple[str, str]]:
"""The planted logs; OSError/ValueError/TypeError when the file is unusable."""
raw = json.loads(Path(path).read_text(encoding="utf-8"))
if not isinstance(raw, list):
msg = "expected a JSON list of [device_id, alarm] pairs"
raise TypeError(msg)
return [_pair(entry) for entry in raw]

View File

@ -0,0 +1,119 @@
"""``--dry-run --published FILE``: plant the phone's logs without a backend.
The live check of the bypass ring (C8, 2026-11-22) could not see ``ring:
bypass`` from the CLI: there is no test backend to plant a ``bypass`` event
in. The file stands in for ``fetch_firebase_logs()`` -- a dry run only, so
a planted world never rings or writes a latch.
"""
from __future__ import annotations
import json
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, patch
import pytest
from wake_alarm import _fallback, _fallback_evening, _fallback_observe
from wake_alarm._fallback_latch import read_latch
from wake_alarm._published_file import load_published
from wake_alarm._sync import Alarm
if TYPE_CHECKING:
from collections.abc import Generator
from pathlib import Path
DAY = "2026-11-22"
def _alarm_json(*events: dict[str, object]) -> dict[str, object]:
return {"alarm": {"fields": {"phone_events": [list(events), "h"]}}}
def _bypass(at: str) -> dict[str, object]:
return {"at": f"{DAY}T{at}+01:00", "kind": "bypass", "data": {"date": DAY}}
def _write(tmp_path: Path, content: object) -> str:
path = tmp_path / "published.json"
path.write_text(json.dumps(content), encoding="utf-8")
return str(path)
@pytest.fixture(autouse=True)
def no_backend() -> Generator[MagicMock]:
"""Alarm 08:00 and a Firebase fetch that must never run."""
fetch = MagicMock(side_effect=AssertionError("fetched Firebase"))
with (
patch.object(_fallback_observe, "get_alarm", return_value=Alarm(8, 0, "c")),
patch.object(_fallback_observe, "fetch_firebase_logs", fetch),
patch.object(_fallback_evening, "fetch_firebase_logs", fetch),
):
yield fetch
def _dry_run(path: str, at: str) -> int:
return _fallback.main(["--dry-run", "--at", f"{DAY}T{at}", "--published", path])
def test_a_planted_bypass_rings_in_a_dry_run(
tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
path = _write(tmp_path, [["phone", _alarm_json(_bypass("10:15:00"))]])
assert _dry_run(path, "10:30") == 0
assert "WOULD RING: bypass" in capsys.readouterr().out
assert read_latch(DAY) is None
def test_raw_text_is_passed_through_as_is(tmp_path: Path) -> None:
raw = json.dumps(_alarm_json(_bypass("08:05:00")))
path = _write(tmp_path, [["phone", raw], ["tablet", {"alarm": {}}]])
assert load_published(path) == [
("phone", raw),
("tablet", '{"alarm": {}}'),
]
def test_an_evening_dry_run_reads_the_file_too(
tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
event = {
"at": f"{DAY}T21:00:00+01:00",
"kind": "notifications",
"data": {"enabled": False},
}
path = _write(tmp_path, [["phone", _alarm_json(event)]])
assert _dry_run(path, "21:05") == 0
assert "firebase=ok" in capsys.readouterr().out
@pytest.mark.parametrize("mode", ["--tick", "--show"])
def test_published_needs_dry_run(tmp_path: Path, mode: str) -> None:
path = _write(tmp_path, [])
with pytest.raises(SystemExit) as exc:
_fallback.main([mode, "--published", path])
assert exc.value.code == 2
@pytest.mark.parametrize(
"content",
[
{"phone": {}},
[["phone"]],
[[1, "{}"]],
[["phone", 3]],
],
)
def test_a_malformed_file_is_refused(tmp_path: Path, content: object) -> None:
with pytest.raises(SystemExit) as exc:
_dry_run(_write(tmp_path, content), "08:10")
assert exc.value.code == 2
def test_a_missing_or_unparsable_file_is_refused(tmp_path: Path) -> None:
bad = tmp_path / "bad.json"
bad.write_text("{", encoding="utf-8")
for path in (str(bad), str(tmp_path / "absent.json")):
with pytest.raises(SystemExit) as exc:
_dry_run(path, "08:10")
assert exc.value.code == 2