grocery-bot

parsing.py (7849B)

---

 """Quantity parsing, ingredient merging, and /addrecipe text parsing."""
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass
 from fractions import Fraction
 
 # Rough keyword heuristic for keto auto-suggestion -- there's no nutrition
 # database backing this, it's just a carb-keyword check. Always manually
 # overridable via the "Keto:" field in /addrecipe.
 HIGH_CARB_KEYWORDS = {
     "sugar", "flour", "rice", "pasta", "bread", "potato", "corn", "oats",
     "honey", "syrup",
 }
 
 
 def parse_quantity(raw: str | None) -> Fraction | None:
     """Parse '1', '1/2', or '1 1/2' into a Fraction.
 
     Returns None for anything that isn't a plain number/fraction (e.g.
     "a pinch", "to taste") -- callers must treat those as non-mergeable
     rather than guessing a value.
     """
     if not raw:
         return None
     raw = raw.strip()
     if not raw:
         return None
 
     total = Fraction(0)
     matched_any = False
     for part in raw.split():
         if re.fullmatch(r"\d+/\d+", part):
             num, den = part.split("/")
             total += Fraction(int(num), int(den))
             matched_any = True
         elif re.fullmatch(r"\d+(\.\d+)?", part):
             total += Fraction(part)
             matched_any = True
         else:
             return None
     return total if matched_any else None
 
 
 def format_quantity(value: Fraction) -> str:
     """Format a Fraction back to display form, e.g. Fraction(3, 2) -> '1 1/2'."""
     whole, rem = divmod(value.numerator, value.denominator)
     if rem == 0:
         return str(whole)
     if whole == 0:
         return f"{rem}/{value.denominator}"
     return f"{whole} {rem}/{value.denominator}"
 
 
 @dataclass
 class Item:
     name: str
     quantity: str | None
     unit: str | None
     category: str | None
     source: str  # 'staple' | 'recipe' | 'freeform'
 
 
 def merge_ingredients(items: list[Item]) -> list[Item]:
     """Merge items by (normalized name, unit).
 
     Matching name+unit pairs have their quantities summed when both parse
     as numbers. Mismatched units, or quantities that don't parse (e.g. "a
     pinch"), are kept as separate line items rather than guessing a
     conversion -- per CLAUDE.md's merge rules.
     """
     merged: dict[tuple[str, str | None], Item] = {}
     passthrough: list[Item] = []
 
     for item in items:
         key_name = item.name.strip().lower()
         key_unit = (item.unit or "").strip().lower() or None
         qty = parse_quantity(item.quantity)
 
         if qty is None:
             passthrough.append(item)
             continue
 
         key = (key_name, key_unit)
         if key in merged:
             existing = merged[key]
             existing_qty = parse_quantity(existing.quantity)
             merged[key] = Item(
                 name=existing.name,
                 quantity=format_quantity(existing_qty + qty),
                 unit=existing.unit,
                 category=existing.category,
                 source=existing.source,
             )
         else:
             merged[key] = item
 
     return list(merged.values()) + passthrough
 
 
 def group_by_category(items: list[Item]) -> list[tuple[str | None, list[Item]]]:
     """Group items by category, preserving first-seen category order.
 
     Items with no category (None) are grouped together and always listed
     last -- no attempt is made to guess a category from the ingredient
     name, so anything not explicitly categorized just lands in one
     leftover group instead of being sorted (or mis-sorted) automatically.
     """
     groups: dict[str | None, list[Item]] = {}
     for item in items:
         groups.setdefault(item.category, []).append(item)
 
     ordered = [(cat, group) for cat, group in groups.items() if cat is not None]
     if None in groups:
         ordered.append((None, groups[None]))
     return ordered
 
 
 def suggest_keto(ingredient_names: list[str]) -> bool:
     """Flag False if any ingredient name contains a high-carb keyword."""
     for name in ingredient_names:
         lname = name.lower()
         if any(keyword in lname for keyword in HIGH_CARB_KEYWORDS):
             return False
     return True
 
 
 SECTION_HEADERS = {"ingredients", "instructions", "nutrition"}
 
 
 def parse_recipe_text(name: str, body: str) -> dict:
     """Parse a recipe body pasted as free-form text (e.g. copied straight
     from a recipe blog) into ingredients/instructions.
 
     The recipe name is passed in separately rather than parsed out of the
     body -- real copy-pasted recipes usually don't include the page title
     in the copied text, so there's nothing reliable to extract it from.
 
     Section headers ("Ingredients", "Instructions", "Nutrition") are
     matched case-insensitively with or without a trailing colon. Before
     the first recognized header, lines default to the "ingredients"
     section, since most pasted recipes list ingredients first, unlabeled.
     A "Nutrition" section, if present, is recognized and discarded (out
     of scope per CLAUDE.md).
 
     Ingredient lines containing "|" are parsed as
     "<quantity> | <unit> | <name> | <category>" for precise manual entry.
     Lines without "|" are kept whole as the ingredient name (quantity/
     unit/category left unset) -- there's no reliable way to split "2
     medium yellow onions, very finely chopped" into quantity/unit/name
     without a real NLP ingredient parser, so that's not attempted; those
     items just won't auto-merge by quantity later.
 
     Optional metadata lines, matched anywhere in the body:
         Servings: <n>
         Source: <text or url>
         Keto: yes|no   (omit to auto-suggest from ingredient names)
     """
     name = name.strip()
     if not name:
         raise ValueError("a recipe name is required")
 
     fields = {"servings": None, "source": None, "is_keto": None}
     ingredients: list[dict] = []
     instructions_lines: list[str] = []
     section = "ingredients"
 
     for line in body.splitlines():
         stripped = line.strip()
         if not stripped:
             continue
 
         header = stripped.rstrip(":").lower()
         if header in SECTION_HEADERS:
             section = header
             continue
 
         lower = stripped.lower()
         if lower.startswith("servings:"):
             value = stripped.split(":", 1)[1].strip()
             fields["servings"] = int(value) if value.isdigit() else None
             continue
         if lower.startswith("source:"):
             fields["source"] = stripped.split(":", 1)[1].strip()
             continue
         if lower.startswith("keto:"):
             value = stripped.split(":", 1)[1].strip().lower()
             fields["is_keto"] = value in ("yes", "true", "1")
             continue
 
         if section == "ingredients":
             if "|" in stripped:
                 parts = [p.strip() for p in stripped.split("|")]
                 parts += [None] * (4 - len(parts))
                 quantity, unit, ing_name, category = parts[:4]
                 ingredients.append({
                     "quantity": quantity or None,
                     "unit": unit or None,
                     "name": ing_name,
                     "category": category or None,
                 })
             else:
                 ingredients.append({
                     "quantity": None, "unit": None,
                     "name": stripped, "category": None,
                 })
         elif section == "instructions":
             instructions_lines.append(stripped)
         # section == "nutrition": intentionally discarded
 
     is_keto = fields["is_keto"]
     if is_keto is None:
         is_keto = suggest_keto([i["name"] for i in ingredients if i["name"]])
 
     return {
         "name": name,
         "servings": fields["servings"],
         "source": fields["source"],
         "is_keto": is_keto,
         "ingredients": ingredients,
         "instructions": "\n".join(instructions_lines),
     }