diet-guard/diet_guard/_claude_schema.py
Krzysztof kuhy Rudnicki 6cd3470502 Add the Claude meal estimator
estimate_meal(text, photo) -> Estimate runs Claude through
claude_agent_sdk in an isolated CLAUDE_CONFIG_DIR: a copy of the access
token (no refresh token, no MCP tokens) and the diet-food skill, never
kuhy's ~/.claude. The skill text is the system prompt; the closest curated
and derived food-bank rows ride in the user message; the photo is an image
block; the answer is constrained by a JSON schema and validated again.

Failure paths, all fail closed (an EstimateError code, nothing logged):
- no host login, CLI/API error, bad transport: estimate_failed
- more than 45 s: estimate_timeout
- no object, missing/mistyped field, NaN/inf/negative/absurd number,
  grams 0, blank or long desc: estimate_invalid
- neither text nor photo: ValueError before any model call
- failed token refresh is logged, the call then fails as estimate_failed

Live smoke (scratch HOME, nothing logged): "2 jajka sadzone i kromka
chleba" -> 315 kcal in 4.3 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWZHWP4KZ6x5TcXDBFC
2026-11-17 21:05:41 +01:00

137 lines
4.4 KiB
Python

"""The estimator's strict output: a JSON schema and a validator.
The schema goes to the model as ``output_format`` (so the CLI constrains the
answer), and :func:`parse_estimate` re-validates what came back: a model
answer that is not a sane, complete object is never logged. Pure stdlib, so
the gate can import it.
"""
from __future__ import annotations
from dataclasses import dataclass
import math
from typing import Any, Final
MAX_DESC: Final = 120
MAX_GRAMS: Final = 5000.0
MAX_KCAL: Final = 5000.0
_NUMBERS: Final = ("grams", "kcal", "protein_g", "carbs_g", "fat_g")
_NUMBER: Final = {"type": "number", "minimum": 0}
_ITEM_PROPS: Final = {
"name": {"type": "string", "minLength": 1, "maxLength": MAX_DESC},
**dict.fromkeys(_NUMBERS, _NUMBER),
}
#: The JSON schema the model's answer must satisfy.
SCHEMA: Final[dict[str, Any]] = {
"type": "object",
"additionalProperties": False,
"required": ["desc", *_NUMBERS],
"properties": {
"desc": {"type": "string", "minLength": 1, "maxLength": MAX_DESC},
**dict.fromkeys(_NUMBERS, _NUMBER),
"components": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": False,
"required": ["name", *_NUMBERS],
"properties": _ITEM_PROPS,
},
},
},
}
class InvalidEstimateError(ValueError):
"""The model's answer is not a usable estimate."""
@dataclass(frozen=True)
class Estimate:
"""One estimated meal: totals for the whole portion.
Attributes:
desc: Short name for the whole meal.
grams: Total edible weight, greater than 0.
kcal: Energy for the portion.
protein_g: Protein for the portion.
carbs_g: Carbohydrate for the portion.
fat_g: Fat for the portion.
components: Per-item breakdown, or None for a single item.
"""
desc: str
grams: float
kcal: float
protein_g: float
carbs_g: float
fat_g: float
components: tuple[dict[str, object], ...] | None = None
def _number(data: dict[str, Any], key: str, ceiling: float) -> float:
"""``data[key]`` as a finite float in ``[0, ceiling]`` (bool is refused)."""
value = data.get(key)
if isinstance(value, bool) or not isinstance(value, (int, float)):
msg = f"{key} is not a number"
raise InvalidEstimateError(msg)
number = float(value)
if not math.isfinite(number) or not 0 <= number <= ceiling:
msg = f"{key}={value!r} is out of range"
raise InvalidEstimateError(msg)
return number
def _text(data: dict[str, Any], key: str) -> str:
"""``data[key]`` as a non-blank string of at most :data:`MAX_DESC`."""
value = data.get(key)
if not isinstance(value, str) or not value.strip() or len(value) > MAX_DESC:
msg = f"{key} is not a short non-blank string"
raise InvalidEstimateError(msg)
return value.strip()
def _macros(data: dict[str, Any]) -> dict[str, float]:
"""The five numbers every meal and every component carries."""
numbers = {
"grams": _number(data, "grams", MAX_GRAMS),
"kcal": _number(data, "kcal", MAX_KCAL),
}
for key in ("protein_g", "carbs_g", "fat_g"):
numbers[key] = _number(data, key, MAX_GRAMS)
return numbers
def _component(item: object) -> dict[str, object]:
"""One validated component."""
if not isinstance(item, dict):
msg = "a component is not an object"
raise InvalidEstimateError(msg)
return {"name": _text(item, "name"), **_macros(item)}
def parse_estimate(data: object) -> Estimate:
"""Validate the model's answer.
Raises:
InvalidEstimateError: not an object, a field is missing or mistyped,
a number is non-finite, negative or absurd, or ``grams`` is 0.
"""
if not isinstance(data, dict):
msg = "the answer is not an object"
raise InvalidEstimateError(msg)
numbers = _macros(data)
if numbers["grams"] <= 0:
msg = "grams must be greater than 0"
raise InvalidEstimateError(msg)
raw = data.get("components")
components: tuple[dict[str, object], ...] | None = None
if raw is not None:
if not isinstance(raw, list):
msg = "components is not a list"
raise InvalidEstimateError(msg)
components = tuple(_component(item) for item in raw)
return Estimate(desc=_text(data, "desc"), components=components, **numbers)