Upload app.py with huggingface_hub

app.py

@@ -1,21 +1,17 @@
-"""Epicurean Simmer — Build Small Hackathon 2026 (Backyard AI track).
-
-Tell it what you're cooking and what's actually in your kitchen. A 12B agent
-(JetBrains Mellum 2, well under the 32B cap) reasons over the Epicure
-flavour-science server to build a STAGED seasoning plan grounded in real
-pairing data — what to add, what to substitute for what you lack, in what
-order. Then the pot's temperature acts as a clock, surfacing each step on a
-16x2 LCD at the moment the cook needs it.
-
-The hard part is the flavour reasoning, not the temperature. Modes:
-  - Space/ZeroGPU: full model builds the plan
-  - MOCK_LLM=1:    scripted planner, still calling Epicure live (no GPU needed)
+"""Pinch — Build Small Hackathon 2026 (Backyard AI track).
+
+Photograph your ingredients; a small vision model reads them, a 12B agent
+(JetBrains Mellum 2) decides a dish and builds a seasoning plan grounded in the
+Epicure flavour model — what to add, what to substitute for what you lack, in
+what order — and runs code for the amounts. Optionally FLUX renders the dish.
+
+Modes:
+  - full:       MiniCPM-V (vision) + Mellum 2 (reasoning) + Epicure + sandbox
+  - MOCK_LLM=1: scripted planner, still calling Epicure live (no model needed)
 """
 
 import json
 import os
-import threading
-import time
 
 # Load .env for local dev BEFORE importing modules that read os.environ at import
 # time (agent/vision/imagery). No-op on a Space (no file) or if dotenv is absent.
@@ -29,10 +25,7 @@ except ImportError:
 import gradio as gr
 import pandas as pd
 
-from agent import (
-    build_plan, classify_phase, lcd_for_phase, parse_pantry, scripted_plan,
-    suggest_dish,
-)
+from agent import build_plan, parse_pantry, scripted_plan, suggest_dish
 from epicure_client import EpicureMCP
 from imagery import generate_dish_image
 from vision import detect_ingredients
@@ -92,69 +85,22 @@ MCP = EpicureMCP()
 
 # --------------------------------------------------------------------- state
 
-class KitchenState:
-    def __init__(self):
-        self.lock = threading.Lock()
-        self.reset()
-
-    def reset(self):
-        self.t0 = time.monotonic()
-        self.log = []
-        self.phase = "warming up"
-        self.plan = {"dish": "", "core": "", "steps": [], "notes": [], "source": ""}
-        self.lcd = {"line1": "Epicurean", "line2": "Plan a dish", "stage": ""}
-
-    def add_reading(self, temp: float):
-        with self.lock:
-            self.log.append((time.monotonic() - self.t0, float(temp)))
-            self.phase = classify_phase(self.log)
-            if self.plan["steps"]:
-                self.lcd = lcd_for_phase(self.plan, self.phase, temp)
-            return self.phase
-
+# ----------------------------------------------------------- planning (the AI)
 
-STATE = KitchenState()
+CURRENT_PLAN = {"dish": "", "core": "", "steps": [], "notes": [], "source": ""}
 
 
-# ----------------------------------------------------------- planning (the AI)
-
 def make_plan(dish: str, pantry: str, constraints: str) -> dict:
-    """Run the agent once to build the staged plan. The expensive reasoning
-    happens here, not per-reading — cooking then costs zero inference."""
+    """Run the agent once to build the plan (and remember it for the UI)."""
+    global CURRENT_PLAN
     if MOCK_LLM:
         plan = scripted_plan(dish, pantry, constraints, MCP)
     else:
         plan = build_plan(dish, pantry, constraints, llm_generate, MCP)
-    with STATE.lock:
-        STATE.plan = plan
+    CURRENT_PLAN = plan
     return plan
 
 
-# ----------------------------------------------------- bridge API (hardware)
-
-def ingest_reading(temp: float) -> str:
-    """Called by bridge/serial_bridge.py per probe reading. Just advances the
-    playhead through the already-built plan — no inference per reading."""
-    STATE.add_reading(temp)
-    with STATE.lock:
-        return json.dumps({"line1": STATE.lcd["line1"], "line2": STATE.lcd["line2"]})
-
-
-# ------------------------------------------------------------------ simulator
-
-class SimKettle:
-    def __init__(self):
-        self.temp = 21.0
-
-    def step(self) -> float:
-        import random
-        self.temp += (101.0 - self.temp) * 0.035 + random.uniform(-0.3, 0.3)
-        return round(min(self.temp, 100.2), 1)
-
-
-SIM = SimKettle()
-
-
 # ------------------------------------------------------------------------- ui
 
 STAGE_ORDER = ["bloom", "aromatics", "body", "finish"]
@@ -186,26 +132,6 @@ def render_plan(plan: dict) -> str:
     return "\n\n".join(blocks)
 
 
-def lcd_html(line1: str, line2: str) -> str:
-    return f"""
-    <div style="background:#0a2a12;border:6px solid #1a1a1a;border-radius:8px;
-                padding:14px 18px;width:fit-content;font-family:monospace;">
-      <div style="color:#7CFC8A;font-size:1.6em;letter-spacing:0.25em;
-                  white-space:pre;">{line1:<16}</div>
-      <div style="color:#7CFC8A;font-size:1.6em;letter-spacing:0.25em;
-                  white-space:pre;">{line2:<16}</div>
-    </div>"""
-
-
-def cook_snapshot():
-    with STATE.lock:
-        df = pd.DataFrame(STATE.log, columns=["seconds", "celsius"])
-        lcd, phase, plan = dict(STATE.lcd), STATE.phase, dict(STATE.plan)
-    stage = lcd.get("stage", "")
-    status = f"**Pot:** {phase}" + (f" → cooking stage **{stage}**" if stage else "")
-    return df, lcd_html(lcd["line1"], lcd["line2"]), status
-
-
 @spaces.GPU(duration=60)
 def detect_from_photo(image, current_pantry):
     """Run the VLM on the uploaded photo and merge its findings into the pantry
@@ -242,31 +168,14 @@ def on_see_dish(dish, pantry, constraints, photo):
     return dish, image, note
 
 
-def sim_tick():
-    STATE.add_reading(SIM.step())
-    return cook_snapshot()
-
-
-def reset_pot():
-    with STATE.lock:
-        plan = dict(STATE.plan)
-    STATE.t0 = time.monotonic()
-    STATE.log = []
-    STATE.phase = "warming up"
-    STATE.plan = plan  # keep the plan; just cool the pot
-    SIM.__init__()
-    return cook_snapshot()
-
-
 with gr.Blocks(title="Pinch") as demo:
     gr.Markdown(
         "# 🤏 Pinch\n"
-        "**Snap a photo of your ingredients — I'll work out what to cook, plan the "
-        "seasoning grounded in real flavour science, compute the amounts, and time "
-        "it to your pot.**  \n"
+        "**Snap a photo of your ingredients — I'll work out what to cook and plan the "
+        "seasoning, grounded in real flavour science, with the amounts worked out.**  \n"
         "_Vision reads your shelf; a 12B agent picks a dish, reasons over the Epicure "
         "flavour model (1,790 ingredients from ~4M recipes), and runs code for the "
-        "quantities. The temperature is just the clock._"
+        "quantities._"
     )
 
     with gr.Row():
@@ -287,7 +196,7 @@ with gr.Blocks(title="Pinch") as demo:
                                     label="Agent's tool calls (Epicure + sandbox)", wrap=True)
         with gr.Column(scale=1):
             gr.Markdown("### 3 · The plan")
-            plan_md = gr.Markdown(render_plan(STATE.plan))
+            plan_md = gr.Markdown(render_plan(CURRENT_PLAN))
             see_btn = gr.Button("✨ See the dish (FLUX.2 klein)")
             dish_image = gr.Image(label="Dish preview", height=260)
             image_note = gr.Markdown("")
@@ -296,9 +205,5 @@ with gr.Blocks(title="Pinch") as demo:
     plan_btn.click(on_plan, [dish, pantry, constraints], [dish, plan_md, tool_log])
     see_btn.click(on_see_dish, [dish, pantry, constraints, photo], [dish, dish_image, image_note])
 
-    # Kept (no UI): optional hardware bridge can still push plan steps to a
-    # physical 16x2 LCD via this endpoint — see bridge/serial_bridge.py.
-    gr.api(ingest_reading, api_name="ingest_reading")
-
 if __name__ == "__main__":
     demo.launch()