diet-guard/diet_guard/_kuchnia_spread.py
Krzysztof kuhy Rudnicki 24be05b9c3 feat: mirror the catering parser and slot spread in Dart, gated by one fixture
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
2026-08-23 08:00:54 +02:00

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)