From c630c4c9efca4fb9525e79d5eaf68a35e6a6a779 Mon Sep 17 00:00:00 2001 From: Foothills Digital Date: Fri, 6 Nov 2026 11:08:05 -0700 Subject: [PATCH] fix(likes): prune spent records from flags.json flags.json only ever grew: each hourly write laid this run's records over the stored copy and never removed anything. The write now also drops records nothing reads again: those for entries no longer in entries.json, and reviewed ones whose cooldown has run out (1 day for a burst, 7 for a drip), which _due already treats the same as no record. Only records this run has seen are pruned. On a 409 re-read, a record another writer added since (rot moving a renamed entry's key, say) is left alone, since this run's list may not know that name yet. The trust cache half of the issue already landed in 7df8824, which drops entries past their TTL on every write. --- scripts/sync_likes.py | 24 +++++++++++++++++++++--- scripts/tests/test_likes.py | 20 ++++++++++++++++++++ 2 files changed, 41 insertions(+), 3 deletions(-) diff --git a/scripts/sync_likes.py b/scripts/sync_likes.py index e7c4c9f..441a96a 100644 --- a/scripts/sync_likes.py +++ b/scripts/sync_likes.py @@ -202,8 +202,17 @@ def _report(gh, todo: list[tuple[str, str, str, str]], flags: dict, now: datetim flags[key][kind] = _record(kind, agg, now, aggregate=True) -def _merge_flags(flags: dict, before: dict): - """A mutate for update_json: lay this run's new and changed records over the stored copy. +def _spent(key: str, kind: str, rec: dict, listed: set[str], now: datetime) -> bool: + """A record nothing reads again: its entry left the list, or it was reviewed and its cooldown has + run out, which _due already treats the same as no record.""" + if key not in listed: + return True + reviewed = rec.get("reviewed_at") + return reviewed is not None and now - _parse(reviewed) >= COOLDOWN.get(kind, WEEK) + + +def _merge_flags(flags: dict, before: dict, listed: set[str], now: datetime): + """A mutate for update_json: lay this run's new and changed records over the stored copy, then drop spent ones. Re-read on a 409, so records another writer stored survive, and so do the issue numbers this run opened: losing one would open the same issue again next hour. @@ -213,6 +222,13 @@ def mutate(cur): for kind, r in recs.items(): if before.get(k, {}).get(kind) != r: cur.setdefault(k, {})[kind] = r + # Only records this run has seen: one another writer added since (rot moving a renamed + # entry's key, say) may belong to a name this run's list doesn't know yet. + for k in list(cur): + cur[k] = {kind: r for kind, r in cur[k].items() + if not (flags.get(k, {}).get(kind) == r and _spent(k, kind, r, listed, now))} + if not cur[k]: + del cur[k] return cur return mutate @@ -330,7 +346,9 @@ def trusted(login): } snap_path = f"snapshots/{now:%Y-%m-%d}.json" - flags_write = ("flags.json", _merge_flags(flags, prev_flags or {}), "chore(stats): record Like reviews") + # Every entry, hidden ones included: only a removed entry's records go. + on_list = {normalize_repo(e["repo"]) for e in entries} + flags_write = ("flags.json", _merge_flags(flags, prev_flags or {}, on_list, now), "chore(stats): record Like reviews") if candidates: try: diff --git a/scripts/tests/test_likes.py b/scripts/tests/test_likes.py index 7a3cbad..d4a0d8a 100644 --- a/scripts/tests/test_likes.py +++ b/scripts/tests/test_likes.py @@ -394,6 +394,26 @@ def flags(self, issue=7, reviewed=None, kind="burst"): rec = {"kind": kind, "issue": issue, "opened_at": iso(NOW - timedelta(days=2)), "reviewed_at": reviewed} return {"flags.json": {"o/a": {kind: rec}}} + def test_spent_flags_are_pruned(self): + def rec(kind, reviewed): + return {"kind": kind, "issue": 7, "opened_at": iso(NOW - timedelta(days=30)), + "reviewed_at": None if reviewed is None else iso(NOW - reviewed)} + stats = {"flags.json": { + "o/a": {"burst": rec("burst", timedelta(days=2)), "drip": rec("drip", timedelta(days=3))}, + "o/b": {"burst": rec("burst", timedelta(hours=2)), "drip": rec("drip", timedelta(days=8))}, + "o/gone": {"burst": rec("burst", None)}, + }} + w = World([entry("o/a"), entry("o/b", status="hidden")], {"o/a": [node("x")], "o/b": []}, + stats=stats, issues=[{"number": 7}]) + w.run() + # Past its cooldown, off the list, or both kinds gone: dropped. Inside its cooldown: kept. + self.assertEqual(w.written("flags.json"), {"o/a": {"drip": rec("drip", timedelta(days=3))}, + "o/b": {"burst": rec("burst", timedelta(hours=2))}}) + # Nothing else is spent, so the next run writes nothing. + w.persist() + w.run() + self.assertIsNone(w.written("flags.json")) + def test_flag_persists_while_issue_open(self): w = World([entry("o/a")], {"o/a": [node("x")]}, stats=self.flags(), issues=[{"number": 7}]) w.run()