mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-22 15:42:19 +01:00
The phone is getting its own Kuchnia Wikinga importer so the feature works with the PC switched off. That turns a risk `_kuchnia_spread.py` called "theoretical" into a live one: two implementations must now agree exactly on which dishes are dropped, which slot each lands on, and the JSON a banked record encodes to. Disagreement means each device re-adds what the other dropped, and since `add_manual_entry` restamps `t` unconditionally, the whole curated bank republishes to every peer on every refresh. A slot mismatch is worse -- a checkpoint one device offers and the other does not can never be satisfied. So the port lands with its gate rather than after it. One shared fixture, `tests/fixtures/kuchnia_day.json`, is asserted by both `pytest` and `flutter test`: same input, same expected dishes, drops, slots, bank keys and records. Two suites written independently from the same prose is not a gate. The fixture is five real dishes (a scrubbed 2026-08-22 capture) plus synthetic meals that each pin one drop or fallback path -- a per-100 g mix-up, an absurd portion, a stringly-typed number, a non-dict entry, a missing `nutrition`, a missing `mealPriority`, and a twin-dish pair. Without those, "the same meals are dropped" is a vacuous assertion against an all-happy-path capture. Both halves were mutation-checked: flipping an expected slot, drop count or record value fails each suite, and flipping `435.0` to `435` fails the byte-identity test while the value comparison still passes, which is why both exist. Three traps the port had to survive, each caught before it shipped: - `_ENERGY_TOLERANCE` is **0.35**. The prose said "~1%", which describes how closely the captured day agreed, not the threshold; porting 0.01 would drop dishes the PC keeps. That paragraph now says so. - `jsonEncode(435)` emits `435` where Python emits `435.0`, so every Dart macro is forced to `double` and a canonical-encoding test pins it. - Dart's `List.sort` is unstable where Python's `sorted` is stable, so the Dart comparator carries the payload index as a final tiebreak. The real dishes live in their own file rather than as a literal in the generator: transcribing them by hand corrupted three of the five, and the error was invisible until the generated fixture was diffed against the capture. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QQpCiPaSbyRpwsLkH3dgsX
97 lines
4.1 KiB
Python
97 lines
4.1 KiB
Python
"""Assign catering dishes to meal slots, in the provider's own order.
|
|
|
|
The panel returns each dish with a ``mealPriority`` (1..N: Śniadanie, II
|
|
śniadanie, Obiad, Podwieczorek, Kolacja) -- the order the catering intends them
|
|
to be eaten in. That beats inferring an order from the dish names, and it
|
|
beats spreading them arithmetically, so this module sorts by priority and then
|
|
maps position onto the user's configured slots.
|
|
|
|
Counts rarely match: a 5-meal plan against the default 4 slots means two dishes
|
|
share the first slot. The mapping is ``i * S // N``, which is monotonic
|
|
non-decreasing, keeps the first dish on the first slot and the last on the
|
|
last, and doubles up the earliest slots rather than dropping anything.
|
|
|
|
Integer ``//`` only, never ``round()``. That is repo convention for slot
|
|
arithmetic (``docs/meal-schedule.md``): Python's banker's rounding and Dart's
|
|
half-away-from-zero disagree on ``.5``, and a slot one device offers while the
|
|
other does not is a checkpoint that can never be satisfied.
|
|
|
|
**The mirror now exists**: ``app/lib/services/kuchnia_spread.dart`` runs this
|
|
same mapping on the phone, which fetches the catering menu itself rather than
|
|
waiting for the PC to bank it. The parity risk stopped being theoretical the
|
|
day that landed, so the two implementations are gated by one shared fixture,
|
|
``tests/fixtures/kuchnia_day.json``, asserted by
|
|
``diet_guard/tests/test_kuchnia_parity.py`` *and*
|
|
``app/test/kuchnia_parity_test.dart`` -- same input, same expected slots.
|
|
|
|
One Dart-only hazard has no Python counterpart and is easy to reintroduce:
|
|
``List.sort`` is not stable while :func:`sorted` is, so the Dart comparator
|
|
carries the payload index as a final tiebreak. Without it two dishes sharing
|
|
both a priority and a name could order differently on the two devices.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, NamedTuple
|
|
|
|
from diet_guard._meal_schedule_store import current_schedule
|
|
from diet_guard._slots import day_slots
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Sequence
|
|
|
|
from diet_guard._kuchnia_parse import Dish
|
|
|
|
|
|
class SlottedDish(NamedTuple):
|
|
"""A dish paired with the meal-slot hour it was assigned to."""
|
|
|
|
dish: Dish
|
|
slot: int
|
|
|
|
|
|
def assign_slots(dishes: Sequence[Dish], slots: Sequence[int]) -> list[SlottedDish]:
|
|
"""Pair each dish with a slot hour, following the provider's meal order.
|
|
|
|
Args:
|
|
dishes: The day's dishes, in any order (sorted here by ``priority``).
|
|
slots: The configured slot hours, ascending, e.g. ``(8, 12, 16, 20)``.
|
|
|
|
Returns:
|
|
One :class:`SlottedDish` per dish, ordered by the provider's priority.
|
|
Empty when either input is empty -- a day with no delivery and a
|
|
schedule with no slots are both "nothing to assign", not errors.
|
|
"""
|
|
if not dishes or not slots:
|
|
return []
|
|
# Ties (two dishes sharing a priority) fall back to name so the result is
|
|
# deterministic; a bank import that reshuffles between runs would look like
|
|
# a change and re-stamp every record.
|
|
ordered = sorted(dishes, key=lambda dish: (dish.priority, dish.name))
|
|
count = len(ordered)
|
|
span = len(slots)
|
|
return [
|
|
SlottedDish(dish=dish, slot=slots[index * span // count])
|
|
for index, dish in enumerate(ordered)
|
|
]
|
|
|
|
|
|
def dishes_in_slot_order(dishes: tuple[Dish, ...]) -> tuple[Dish, ...]:
|
|
"""Return ``dishes`` ordered by the provider's own meal priority.
|
|
|
|
So the dish offered for the slot being filled is the one the catering
|
|
actually intends for it, rather than whatever order the payload arrived in.
|
|
"""
|
|
slotted = assign_slots(dishes, day_slots(current_schedule()))
|
|
return tuple(item.dish for item in slotted)
|
|
|
|
|
|
def dish_field_values(dish: Dish) -> tuple[str, tuple[str, ...]]:
|
|
"""Return ``(portion_grams, (kcal, protein, carbs, fat))`` as form strings.
|
|
|
|
Formatted here rather than in the widget code so the numeric formatting is
|
|
covered by a test that needs no display.
|
|
"""
|
|
macros = (dish.kcal, dish.protein_g, dish.carbs_g, dish.fat_g)
|
|
return f"{dish.grams:g}", tuple(f"{value:g}" for value in macros)
|