From 74a39c30542aa16fa7b048c765d70de010c089c0 Mon Sep 17 00:00:00 2001 From: Krzysztof kuhy Rudnicki Date: Mon, 16 Nov 2026 08:29:01 +0100 Subject: [PATCH] Close the lock window when credit lands On 2026-11-16 a manual workout was credited at 07:59 by _session_stream, but the open lock window never rechecked log.json (TRY AGAIN only asked StrongLifts/adb), so kuhy had to mark a sick day. The window now polls log.json mtime every 3 s via Tk after and stands down (decision workout_credited_elsewhere, no second credit), and TRY AGAIN stands down when today is already logged. _verify_phone_workout is deliberately unchanged (shared with early-bird/status). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01WzxdWWfb63jncj9Lca2jeX --- screen_locker/_credit_watch.py | 117 ++++++++++++ screen_locker/_ui_flows.py | 16 +- screen_locker/screen_lock.py | 4 + screen_locker/tests/test_credit_watch.py | 232 +++++++++++++++++++++++ 4 files changed, 367 insertions(+), 2 deletions(-) create mode 100644 screen_locker/_credit_watch.py create mode 100644 screen_locker/tests/test_credit_watch.py diff --git a/screen_locker/_credit_watch.py b/screen_locker/_credit_watch.py new file mode 100644 index 0000000..215bf29 --- /dev/null +++ b/screen_locker/_credit_watch.py @@ -0,0 +1,117 @@ +"""An open lock window closes itself the moment today's workout is credited. + +2026-11-16: the window opened at 07:55:17. kuhy logged a manual workout on the +phone; at 07:59:04 the separate ``_session_stream`` daemon credited it (log row +written, shutdown moved). The open window never noticed: TRY AGAIN only asked +StrongLifts/ADB/HTTP, so it kept saying "stale" and kuhy marked a sick day to +get out. The startup ladder reads ``log.json`` once; this is the same verdict +(``has_logged_today``, HMAC-checked) re-asked whenever the file changes. + +Event-driven on the Tk loop, no thread, no new dependency: each poll is one +``stat`` of the log; the file is parsed only when its (mtime, size, inode) +moved. The credit itself was already written by whoever logged it, so closing +here writes nothing and applies nothing -- it just takes the window down. +""" + +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING + +from screen_locker._decision_log import LockDecision, record_decision + +if TYPE_CHECKING: + from collections.abc import Callable + from pathlib import Path + from tkinter import Misc + +__all__ = ["POLL_MS", "CreditStandDownMixin", "watch_for_credit"] + +_logger = logging.getLogger(__name__) + +# Well inside the 10 s an open window may take to notice a credit. +POLL_MS = 3_000 +_UNSEEN: tuple[int, ...] = (-1,) +_ABSENT: tuple[int, ...] = () + + +def _signature(log_file: Path) -> tuple[int, ...] | None: + """(mtime_ns, size, inode) of the log: ``()`` when absent, None on error.""" + # exists() first: a log nobody has written yet is normal, not a fault, and + # a bare ``except FileNotFoundError`` would be a silent swallow. + if not log_file.exists(): + return _ABSENT + try: + stat = log_file.stat() + except OSError as exc: + _logger.warning( + "Could not stat %s while the lock is up (%s) — keeping the lock " + "and trying again in %d s", + log_file, + exc, + POLL_MS // 1000, + ) + return None + return (stat.st_mtime_ns, stat.st_size, stat.st_ino) + + +def watch_for_credit( + root: Misc, + log_file: Path, + has_logged: Callable[[], bool], + on_credit: Callable[[], None], +) -> None: + """Hand a credit that landed while the window is up to ``on_credit``. + + The first poll always checks (a row may land between startup and arming); + after that ``has_logged`` runs only when the log's signature changed. A + failed check is logged and the poll goes on: one bad read must not end the + only thing watching. Stops re-arming once it fires. + """ + seen = _UNSEEN + + def _tick() -> None: + nonlocal seen + sig = _signature(log_file) + if sig is not None and sig != seen: + seen = sig + try: + if has_logged(): + on_credit() + return + except (OSError, ValueError, TypeError, KeyError) as exc: + _logger.warning( + "Could not check %s for a credit while the lock is up " + "(%s) — keeping the lock and trying again in %d s", + log_file, + exc, + POLL_MS // 1000, + ) + seen = _UNSEEN + root.after(POLL_MS, _tick) + + root.after(POLL_MS, _tick) + + +class CreditStandDownMixin: + """The locker's side: leave through the normal ``close`` once credited.""" + + def _stand_down_for_credit(self) -> None: + """Take the window down because today's workout is already credited. + + Same exit as a credited workout, a test hold or a late carrot: lock + window released, instance lock dropped, exit 0. No row, no credit, no + penalty -- the logger of the workout already did all of that. + """ + record_decision( + LockDecision( + locked=False, + reason="workout_credited_elsewhere", + detail="Today's workout was credited while the lock was up.", + ) + ) + _logger.warning( + "Today's workout was credited by another process while the lock " + "was up — taking the lock down without writing a second credit." + ) + self.close() diff --git a/screen_locker/_ui_flows.py b/screen_locker/_ui_flows.py index d3c315c..b63e5a6 100644 --- a/screen_locker/_ui_flows.py +++ b/screen_locker/_ui_flows.py @@ -14,6 +14,7 @@ from typing import TYPE_CHECKING from screen_locker import _glyphs as g from screen_locker import _manual_workout +from screen_locker._credit_watch import CreditStandDownMixin from screen_locker._source_health import collect_source_findings, explain_findings from screen_locker._ui_flows_lockout import LockoutFlowMixin from screen_locker._ui_flows_sick import SickDayFlowMixin @@ -25,7 +26,9 @@ if TYPE_CHECKING: _logger = logging.getLogger(__name__) -class UIFlowsMixin(SickDayFlowMixin, SickPanelFlowMixin, LockoutFlowMixin): +class UIFlowsMixin( + SickDayFlowMixin, SickPanelFlowMixin, LockoutFlowMixin, CreditStandDownMixin +): """Mixin providing UI flow logic for the screen locker. The sick-day and lockout/penalty flows live in sibling modules and are @@ -50,7 +53,16 @@ class UIFlowsMixin(SickDayFlowMixin, SickPanelFlowMixin, LockoutFlowMixin): self._text(g.WAIT, role="display", color=self._colors.palette.muted) def _start_phone_check(self) -> None: - """Check phone for today's workout immediately at startup.""" + """Check phone for today's workout immediately at startup. + + Also the TRY AGAIN path. Another process (the stream daemon, a manual + log) may have credited today since the window opened; the log is + authoritative, so that closes the window instead of asking the phone + -- a StrongLifts "stale" verdict must never outrank a logged workout. + """ + if self.has_logged_today(): + self._stand_down_for_credit() + return self.paint_phone_check() executor = ThreadPoolExecutor(max_workers=1) self._phone_future = executor.submit(self._verify_phone_workout) diff --git a/screen_locker/screen_lock.py b/screen_locker/screen_lock.py index b3bb420..bb9de1f 100755 --- a/screen_locker/screen_lock.py +++ b/screen_locker/screen_lock.py @@ -35,6 +35,7 @@ from screen_locker._constants import ( PHONE_PENALTY_DELAY_PRODUCTION, SCHEDULED_SKIPS_FILE, ) +from screen_locker._credit_watch import watch_for_credit from screen_locker._decision_log import record_run_aborted from screen_locker._early_bird import EarlyBirdMixin from screen_locker._heat_skip import HeatSkipMixin @@ -214,6 +215,9 @@ class ScreenLocker( self._lock.grab_input() watch_for_hold(self.root, self.close) watch_for_carrot(self.root, self._stand_down_for_carrot) + watch_for_credit( + self.root, self.log_file, self.has_logged_today, self._stand_down_for_credit + ) def close(self) -> None: """Close the application and exit.""" diff --git a/screen_locker/tests/test_credit_watch.py b/screen_locker/tests/test_credit_watch.py new file mode 100644 index 0000000..d9af146 --- /dev/null +++ b/screen_locker/tests/test_credit_watch.py @@ -0,0 +1,232 @@ +"""An open lock window closes itself when another process credits today. + +2026-11-16: the window opened 07:55:17; the `_session_stream` daemon credited a +manual workout at 07:59:04 and the open window never noticed -- TRY AGAIN only +asked StrongLifts/ADB/HTTP -- so kuhy had to mark a sick day to get out. +""" + +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING +from unittest.mock import ANY, MagicMock, patch + +import pytest + +from screen_locker._credit_watch import POLL_MS, watch_for_credit +from screen_locker._day import today_str +from screen_locker._log_mixin import write_signed_entry +from screen_locker.tests.conftest import create_locker + +if TYPE_CHECKING: + from collections.abc import Iterator + from pathlib import Path + + +@pytest.fixture(autouse=True) +def _signing_key(tmp_path: Path) -> Iterator[None]: + key = tmp_path / "hmac.key" + key.write_bytes(b"1" * 32) + with patch("gatelock.log_integrity.DEFAULT_HMAC_KEY_FILE", key): + yield + + +def _credit_today(log_file: Path) -> None: + """What the stream daemon does: a signed row for today in the scratch log.""" + write_signed_entry( + log_file, + today_str(), + {"type": "manual", "workout_id": "wk-1", "source": "phone"}, + ) + + +def _arm( + log_file: Path, *, logged: bool = False +) -> tuple[MagicMock, MagicMock, MagicMock]: + """Arm the watch; return (root, on_credit, has_logged).""" + root, on_credit = MagicMock(), MagicMock() + has_logged = MagicMock(return_value=logged) + watch_for_credit(root, log_file, has_logged, on_credit) + return root, on_credit, has_logged + + +def _fire(root: MagicMock) -> None: + """Run the poll the watch last scheduled.""" + root.after.call_args.args[1]() + + +class TestWatchForCredit: + """The poll on the Tk loop.""" + + def test_polls_well_inside_ten_seconds(self, tmp_path: Path) -> None: + """First check is scheduled at most 5 s out: credit shows in <= 10 s.""" + root, on_credit, _ = _arm(tmp_path / "log.json") + assert POLL_MS <= 5_000 + assert root.after.call_args.args[0] == POLL_MS + on_credit.assert_not_called() + + def test_nothing_logged_keeps_the_window_and_rearms(self, tmp_path: Path) -> None: + """No file, no credit: the window stays and the next poll is armed.""" + root, on_credit, _ = _arm(tmp_path / "log.json") + _fire(root) + on_credit.assert_not_called() + assert root.after.call_count == 2 + + def test_credit_landing_after_arming_fires_once_and_stops( + self, tmp_path: Path + ) -> None: + """A row written after arming is handed over; the poll is not re-armed.""" + log_file = tmp_path / "log.json" + root = MagicMock() + on_credit = MagicMock() + watch_for_credit(root, log_file, log_file.exists, on_credit) + _fire(root) + on_credit.assert_not_called() + _credit_today(log_file) + _fire(root) + on_credit.assert_called_once_with() + assert root.after.call_count == 2 + + def test_unchanged_file_is_not_reread(self, tmp_path: Path) -> None: + """Steady state is one stat per poll: the log is parsed only on change.""" + log_file = tmp_path / "log.json" + log_file.write_text("{}") + root, _, has_logged = _arm(log_file) + _fire(root) + _fire(root) + _fire(root) + assert has_logged.call_count == 1 + + def test_rewritten_file_is_reread(self, tmp_path: Path) -> None: + """A changed file is checked again even if the first check said no.""" + log_file = tmp_path / "log.json" + log_file.write_text("{}") + root, _, has_logged = _arm(log_file) + _fire(root) + log_file.write_text('{"1999-01-01": []}') + _fire(root) + assert has_logged.call_count == 2 + + def test_credit_present_before_first_poll_is_caught(self, tmp_path: Path) -> None: + """A row that landed between startup and arming is not missed.""" + log_file = tmp_path / "log.json" + _credit_today(log_file) + root, on_credit, _ = _arm(log_file, logged=True) + _fire(root) + on_credit.assert_called_once_with() + + def test_read_failure_is_logged_and_the_poll_survives( + self, tmp_path: Path, caplog: pytest.LogCaptureFixture + ) -> None: + """A failing check warns and re-arms; it must not end the only watcher.""" + log_file = tmp_path / "log.json" + log_file.write_text("{}") + root, on_credit, has_logged = _arm(log_file) + has_logged.side_effect = OSError("disk gone") + with caplog.at_level(logging.WARNING, logger="screen_locker._credit_watch"): + _fire(root) + on_credit.assert_not_called() + assert root.after.call_count == 2 + assert "disk gone" in caplog.text + + def test_unreadable_stat_is_logged_not_swallowed( + self, tmp_path: Path, caplog: pytest.LogCaptureFixture + ) -> None: + """A log that exists but cannot be stat'ed is reported, not skipped.""" + log_file = tmp_path / "log.json" + log_file.write_text("{}") + root, on_credit, _ = _arm(log_file) + with ( + patch("pathlib.Path.stat", side_effect=PermissionError("no stat")), + caplog.at_level(logging.WARNING, logger="screen_locker._credit_watch"), + ): + _fire(root) + on_credit.assert_not_called() + assert "no stat" in caplog.text + assert root.after.call_count == 2 + + +class TestLockerClosesOnCredit: + """The locker side: wiring, the retry path and the stand-down itself.""" + + def test_construction_arms_the_watch( + self, mock_tk: MagicMock, tmp_path: Path + ) -> None: + """A built locker watches its own log, with its own stand-down.""" + with patch("screen_locker.screen_lock.watch_for_credit") as watch: + locker = create_locker(mock_tk, tmp_path) + watch.assert_called_once_with( + locker.root, + locker.log_file, + ANY, # create_locker patches has_logged_today during construction + locker._stand_down_for_credit, + ) + + def test_open_window_closes_when_another_process_credits( + self, mock_tk: MagicMock, mock_sys_exit: MagicMock, tmp_path: Path + ) -> None: + """Window open -> row appended to the scratch log -> next poll closes it.""" + locker = create_locker(mock_tk, tmp_path) + root = MagicMock() + watch_for_credit( + root, + locker.log_file, + locker.has_logged_today, + locker._stand_down_for_credit, + ) + _fire(root) + mock_sys_exit.assert_not_called() + _credit_today(locker.log_file) + with ( + patch.object(locker, "_lock") as lock, + patch("screen_locker._credit_watch.record_decision") as record, + ): + _fire(root) + lock.close.assert_called_once_with() + mock_sys_exit.assert_called_once_with(0) + decision = record.call_args.args[0] + assert decision.locked is False + assert decision.reason == "workout_credited_elsewhere" + + def test_stand_down_writes_no_credit_of_its_own( + self, mock_tk: MagicMock, mock_sys_exit: MagicMock, tmp_path: Path + ) -> None: + """Closing must not double-credit: no new log row, no credit applied.""" + locker = create_locker(mock_tk, tmp_path) + _credit_today(locker.log_file) + before = locker.log_file.read_bytes() + with ( + patch.object(locker, "_lock"), + patch.object(locker, "_apply_workout_credit") as credit, + ): + locker._stand_down_for_credit() + credit.assert_not_called() + assert locker.log_file.read_bytes() == before + mock_sys_exit.assert_called_once_with(0) + + def test_try_again_with_todays_credit_closes_instead_of_asking_the_phone( + self, mock_tk: MagicMock, mock_sys_exit: MagicMock, tmp_path: Path + ) -> None: + """2026-11-16: TRY AGAIN said 'stale' though the log held today's row.""" + locker = create_locker(mock_tk, tmp_path) + _credit_today(locker.log_file) + with ( + patch.object(locker, "_lock"), + patch.object(locker, "_verify_phone_workout") as verify, + ): + locker._start_phone_check() + verify.assert_not_called() + mock_sys_exit.assert_called_once_with(0) + + def test_try_again_without_credit_still_asks_the_phone( + self, mock_tk: MagicMock, mock_sys_exit: MagicMock, tmp_path: Path + ) -> None: + """Not logged today: the retry runs the normal phone check.""" + locker = create_locker(mock_tk, tmp_path) + with patch.object( + locker, "_verify_phone_workout", return_value=("stale", "old") + ) as verify: + locker._start_phone_check() + locker._phone_future.result(timeout=5) + verify.assert_called_once_with() + mock_sys_exit.assert_not_called()