mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-19 23:34:24 +01:00
A meal logged on the phone while the gate window was up changed nothing until Fetch was pressed: the new credit watch only fires on a local write to the food log, and the PC never pulled on its own. While a non-demo window is open it now pulls peer logs every 30 s, with the Fetch button's own narrow pull on a worker thread. One pull is in flight at a time (shared with the button), failures are logged and retried, and the window stays up. The pull's write trips the watch, which closes through the usual reconcile path. gatelock moves to 0.14.0 for watch_credit. refresh_peer_logs also read the local log before the peer downloads and wrote it after, so a meal logged during the pull was overwritten. It now merges the peers first and reads the local log just before the write. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWWfb63jncj9Lca2jeX
93 lines
3.3 KiB
Python
93 lines
3.3 KiB
Python
"""The open gate window pulls peer logs on its own, every ~30 s.
|
|
|
|
``watch_credit`` (see :mod:`diet_guard._gatelock_credit`) fires on a *local*
|
|
write to the food log, and until 2026-11-16 nothing on the PC wrote while the
|
|
window was up: a meal logged on the phone waited for the user to press Fetch.
|
|
This runs the Fetch button's own narrow pull -- :func:`pull_peer_logs` through
|
|
:func:`start_fetch`, no new sync client -- on a timer. When a peer has logged
|
|
something the pull writes the local log, and that write trips the watch.
|
|
|
|
* **Off the Tk thread**, a daemon worker and a Tk-side poll, exactly as the
|
|
button does it.
|
|
* **One pull at a time, shared with the button.** Both use the window's
|
|
``fetch_result`` slot: a tick while the button's fetch runs does nothing, and
|
|
a click while a tick's pull runs is ignored by the button's own guard.
|
|
* **Silent and never an unlock.** No status line (it would say "nothing new"
|
|
every 30 s over whatever the user is doing) and no direct close: the watch
|
|
owns that, on the same ``due_slots`` verdict as every other path.
|
|
* **Fail closed.** A failed pull is logged and retried at the next interval; the
|
|
window stays up.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import queue
|
|
from typing import TYPE_CHECKING, Protocol
|
|
|
|
from diet_guard._gatelock_fetch import FETCH_POLL_MS, start_fetch
|
|
from diet_guard._sync_refresh import pull_peer_logs
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
from tkinter import Misc
|
|
|
|
__all__ = ["PEER_PULL_MS", "arm_peer_pull"]
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
#: Between the end of one pull and the start of the next. A phone-logged meal
|
|
#: closes the window within about this long.
|
|
PEER_PULL_MS = 30_000
|
|
|
|
|
|
class _PullHost(Protocol):
|
|
"""The slice of the gate window the timer needs."""
|
|
|
|
root: Misc
|
|
#: The shared in-flight slot; None when no pull is running.
|
|
fetch_result: queue.Queue[str | None] | None
|
|
|
|
|
|
def _poll_closure(host: _PullHost, interval_ms: int) -> Callable[[], None]:
|
|
"""Build the Tk-side poll that collects a finished pull."""
|
|
|
|
def _poll() -> None:
|
|
result = host.fetch_result
|
|
if result is None:
|
|
return
|
|
try:
|
|
reason = result.get_nowait()
|
|
except queue.Empty:
|
|
host.root.after(FETCH_POLL_MS, _poll)
|
|
return
|
|
host.fetch_result = None
|
|
if reason is not None:
|
|
_logger.warning("Background peer pull failed, retrying: %s", reason)
|
|
host.root.after(interval_ms, _tick_closure(host, interval_ms))
|
|
|
|
return _poll
|
|
|
|
|
|
def _tick_closure(host: _PullHost, interval_ms: int) -> Callable[[], None]:
|
|
"""Build the timer callback: start a pull unless one is already running."""
|
|
|
|
def _tick() -> None:
|
|
if host.fetch_result is not None:
|
|
host.root.after(interval_ms, _tick)
|
|
return
|
|
host.fetch_result = start_fetch(pull_peer_logs)
|
|
host.root.after(FETCH_POLL_MS, _poll_closure(host, interval_ms))
|
|
|
|
return _tick
|
|
|
|
|
|
def arm_peer_pull(host: _PullHost, interval_ms: int = PEER_PULL_MS) -> None:
|
|
"""Start pulling peer logs in the background while the window is up.
|
|
|
|
Args:
|
|
host: The gate window (its Tk root and shared in-flight pull slot).
|
|
interval_ms: Pause between pulls.
|
|
"""
|
|
host.root.after(interval_ms, _tick_closure(host, interval_ms))
|