mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-10 18:07:20 +01:00
Krzysztof kuhy Rudnicki
26f1770090
Pulls the day's delivered dishes and their real per-portion macros out of
panel.kuchniavikinga.pl, so a catering meal is one keypress instead of five
retyped numbers.
A delivered meal is not an eaten meal, so nothing is ever logged unattended:
dishes land in the *curated* bank, and entries are written only after an
explicit confirmation. Auto-logging would let the gate satisfy its own
checkpoint from a delivery note, and would record what the courier dropped off
rather than what was eaten.
Three surfaces:
- `diet-guard kuchnia [--log] [--yes]`
- the lock screen's "Today's delivery" button, which prefills the meal form
dish by dish (the user still clicks Log & Continue)
- a warm-up after each logged meal, on the existing background thread
All event-driven; no new systemd timer. The two automatic paths go through
`refresh_delivery_once`, guarded to one fetch per day.
The panel is an undocumented white-labelled Dietly API; the endpoint map was
recovered from its JS bundles and confirmed against live responses. Notes,
including the traps, are in docs/kuchnia-wikinga.md.
Load-bearing details:
* Macros are per portion and `weight` is that portion in grams -- proven, not
assumed: 4P+4C+9F reproduces the stated calories within ~1% on every meal of
the captured day. `_energy_is_consistent` re-runs that check per dish and
drops any that fails; a per-100g mix-up is invisible in a payload and would
silently skew every logged meal by a factor of several.
* `bank_dishes` compares nutritional fields before calling `add_manual_entry`,
which restamps `t` unconditionally. Without the compare, every refresh
republishes the whole curated bank to every peer. Tests assert on call count.
* Duplicate log suppression reads today's synced log, not a local marker:
`log_meal` mints a fresh uuid, so a re-import after marker loss would merge
as duplicates on every peer.
* The gate hook is in `on_focus_ready`, not `_cli_gate._should_lock`:
`gate_is_due()` never reads the food bank, so a refresh there could not
change the lock decision while adding a third-party round trip to the ~105ms
`gate --check` fast path.
* `requests` is lazy-imported so the gate's not-due tick does not pay for it.
* Credentials and the cached session cookie live in ~/.config/diet_guard at
mode 600, outside the synced tree. The credentials file is written by hand,
never by the package -- the same contract as sync_token.
`_GateDashboard` is merged into `_GateMealFlow`, and both "pull it in from
elsewhere" flows share one `_PullFlows` mixin: pylint's max-parents counts
every MRO entry, so the gate's controller chain had no room for a new class.
Also adds a side-by-side row for the two pull buttons -- stacking them cost
42px and pushed the tab past the viewport at 1366x768.
989 tests, 100% branch coverage, pre-commit clean.
76 lines
2.7 KiB
Python
76 lines
2.7 KiB
Python
"""Turn confirmed catering dishes into log entries.
|
|
|
|
Nothing here runs without an explicit confirmation from the user -- that is the
|
|
whole design of this feature. A delivered meal is not an eaten meal: if the
|
|
importer wrote entries unattended, the gate would auto-satisfy the exact
|
|
checkpoint it exists to enforce, and the log would record what the courier
|
|
dropped off rather than what was eaten.
|
|
|
|
Duplicate suppression works off **today's log**, not a local "already
|
|
imported" marker. ``log_meal`` mints a fresh uuid per entry, so a re-import
|
|
after a lost marker would merge as duplicates on every peer; comparing against
|
|
the synced log instead is robust to marker loss *and* correct across devices --
|
|
if the phone already logged the dish, the PC sees it and skips.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
from diet_guard._estimator import Nutrition
|
|
from diet_guard._state import log_meal
|
|
from diet_guard._state_today import today_entries
|
|
|
|
if TYPE_CHECKING: # pragma: no cover - typing only
|
|
from collections.abc import Sequence
|
|
|
|
from diet_guard._kuchnia_spread import SlottedDish
|
|
|
|
#: Marks entries this importer created, so the provenance is visible in the log
|
|
#: and in the food bank's ``source`` column.
|
|
SOURCE = "kuchnia wikinga"
|
|
|
|
|
|
def _already_logged(entries: Sequence[dict[str, object]], name: str, slot: int) -> bool:
|
|
"""Return True when today's log already holds this dish in this slot."""
|
|
wanted = name.strip().casefold()
|
|
return any(
|
|
str(entry.get("desc", "")).strip().casefold() == wanted
|
|
and entry.get("slot") == slot
|
|
for entry in entries
|
|
)
|
|
|
|
|
|
def log_dishes(chosen: Sequence[SlottedDish]) -> list[str]:
|
|
"""Log each chosen dish, skipping any already logged today in that slot.
|
|
|
|
Args:
|
|
chosen: The dishes the user confirmed, already paired with slots.
|
|
|
|
Returns:
|
|
The descriptions actually written, in the order they were logged.
|
|
"""
|
|
entries = today_entries()
|
|
written: list[str] = []
|
|
for item in chosen:
|
|
dish = item.dish
|
|
if _already_logged(entries, dish.name, item.slot):
|
|
continue
|
|
log_meal(
|
|
dish.name,
|
|
Nutrition(
|
|
kcal=dish.kcal,
|
|
protein_g=dish.protein_g,
|
|
carbs_g=dish.carbs_g,
|
|
fat_g=dish.fat_g,
|
|
grams=dish.grams,
|
|
source=SOURCE,
|
|
),
|
|
item.slot,
|
|
)
|
|
# Reflect the write locally so two identical dishes in one batch do not
|
|
# both land: today_entries() was read once, before the loop.
|
|
entries = [*entries, {"desc": dish.name, "slot": item.slot}]
|
|
written.append(dish.name)
|
|
return written
|