Added project

README.md

@@ -1,13 +1,64 @@
 ---
 title: EcoChef
-emoji: 💻
-colorFrom: gray
-colorTo: blue
+emoji: 🌍
+tag: mcp-server-track
+colorFrom: purple
+colorTo: green
 sdk: gradio
 sdk_version: 5.33.1
 app_file: app.py
-pinned: false
+pinned: true
 short_description: Eco-Friendly AI Meal Planner with Food Carbon Insights
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🥗 EcoChef
+
+**Eco-Friendly AI Meal Planner with Food Carbon Insights**
+
+---
+
+### 🚀 Purpose
+
+EcoChef helps reduce food waste and carbon emissions by analyzing your fridge ingredients, predicting spoilage risk, estimating environmental impact, and suggesting optimized meal plans using AI.
+
+[Watch EcoChef in action](https://www.loom.com/share/5b76af542a7b4149a9797dea0e26f789?sid=4a35d86a-c73b-4179-90f6-ddfef1b85023)
+
+---
+
+### ✨ Key Features
+
+* 🧊 Spoilage risk detection for common food items
+* 🌍 Carbon footprint estimation (CO₂e per ingredient)
+* 🍽️ AI-generated meal plans using LLMs
+* 🔄 Smart substitutions to minimize waste
+* 🧾 Interactive Gradio UI + MCP integration
+
+---
+
+### 🧠 Models and APIs Used
+
+* **LLM:** meta-llama/Llama-3.3-70B-Instruct model via Nebius API
+* **Carbon Footprint Data:** Taken from Su-EATABLE LIFE dataset which provides standardized carbon and water footprint values for thousands of food items based on harmonized LCA methodologies
+* **Spoilage Model:** Custom rules-based + JSON dataset of food ingredient curated specially for this project.
+* **Nebius API:** Used to inference llama model for suggesting meal.
+
+---
+
+### 🛠️ Functionality Overview
+
+1. Input your fridge ingredients
+2. EcoChef estimates spoilage and carbon impact
+3. Generates optimized recipes and substitutes
+4. Visualizes results in a user-friendly interface
+
+---
+
+### 🧪 Install dependencies with:
+
+```bash
+pip install -r requirements.txt
+```
+
+Made with ❤️ using Gradio, Llama, Nebius APIs for [Gradio Agents & MCP Hackathon 2025](https://huggingface.co/Agents-MCP-Hackathon) on [Hugging Face](https://huggingface.co)🤗
+
+Created by [tejasashinde](https://huggingface.co/tejasashinde)

app.py

@@ -0,0 +1,327 @@
+import gradio as gr
+from mcp_server import handle_tool_call
+import re
+import json
+
+# --- Load Shelf Life Data ---
+with open("spoilage_data.json", "r") as f:
+    shelf_life_data = json.load(f)
+
+# --- Backend Logic Wrapping ---
+def run_all_tools(text):
+    parsed = handle_tool_call("parse_ingredients", {"text": text})
+    spoilage = handle_tool_call("predict_spoilage", {"items": parsed})
+    carbon = handle_tool_call("estimate_carbon", {"items": parsed})
+
+    items_with_risk = [
+        {**item, "risk": spoilage[i]} for i, item in enumerate(parsed)
+    ]
+
+    meal_plan = handle_tool_call(
+        "generate_meal_plan",
+        {"items": items_with_risk, "spoilage": spoilage, "carbon": carbon, "parsed": parsed}
+    )
+    print(meal_plan)
+
+    return parsed, spoilage, carbon, meal_plan
+
+# --- Output Formatters ---
+
+def format_items_table(meal_plan_json):
+    if isinstance(meal_plan_json, str):
+        try:
+            meal_plan_json = json.loads(meal_plan_json)
+        except json.JSONDecodeError:
+            pass
+
+    ingredient_data = []
+
+    if isinstance(meal_plan_json, list):
+        for block in meal_plan_json:
+            if isinstance(block, dict):
+                for val in block.values():
+                    if isinstance(val, str):
+                        match = re.search(r"```json\n(.*?)```", val, re.DOTALL)
+                        if not match:
+                            match = re.search(r"```(.*?)```", val, re.DOTALL)
+                        if match:
+                            try:
+                                extracted_json = json.loads(match.group(1))
+                                if isinstance(extracted_json, dict):
+                                    ingredient_data = extracted_json.get("ingredientDetails", [])
+                                elif isinstance(extracted_json, list):
+                                    ingredient_data = extracted_json
+                                break
+                            except json.JSONDecodeError:
+                                continue
+
+    if not ingredient_data:
+        return "<div style='color: gray;'>No ingredient data available in meal plan.</div>"
+
+    html = """
+    <style>
+    table {
+        width: 100%;
+        border-collapse: collapse;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        margin-bottom: 30px;
+    }
+    th, td {
+        border: 1px solid #ddd;
+        padding: 10px;
+        text-align: left;
+    }
+    th {
+        background-color: #2a9d8f;
+        color: white;
+    }
+    .expiry-short { color: #d62828; font-weight: bold; }
+    .expiry-medium { color: #f77f00; font-weight: bold; }
+    .expiry-long { color: #2a9d8f; font-weight: bold; }
+    </style>
+    <table>
+        <thead>
+            <tr>
+                <th>Ingredient</th>
+                <th>Expiry / Shelf Life</th>
+                <th>Spoilage Risk</th>
+                <th>Carbon Footprint (kg CO₂e/kg)</th>
+            </tr>
+        </thead>
+        <tbody>
+    """
+
+    for item in ingredient_data:
+        name = item.get("Ingredient", "Unknown").title()
+        expiry_display = item.get("Expiry / Shelf Life", "N/A")
+        risk = item.get("Spoilage Risk", "Unknown").capitalize()
+        carbon_fp_str = str(item.get("Carbon Footprint", "N/A")).replace(" kg CO₂e/kg", "").strip()
+
+        days_match = re.search(r"(\d+)", expiry_display)
+        if days_match:
+            days = int(days_match.group(1))
+            if days <= 2:
+                expiry_class = "expiry-short"
+                icon = "⏰"
+            elif days <= 5:
+                expiry_class = "expiry-medium"
+                icon = "📆"
+            else:
+                expiry_class = "expiry-long"
+                icon = "✅"
+        else:
+            expiry_class = ""
+            icon = "❓"
+
+        expiry_html = f'<span class="{expiry_class}">{icon} {expiry_display}</span>'
+
+        risk_color = {"High": "red", "Medium": "orange", "Low": "green"}.get(risk, "gray")
+
+        try:
+            carbon_value = float(carbon_fp_str)
+            intensity = "🌍" * int(min(carbon_value / 0.5, 5))
+            carbon_html = f"{carbon_value:.2f} {intensity}"
+        except ValueError:
+            carbon_html = "🌫️ N/A"
+
+        html += f"""
+        <tr>
+            <td><b>{name}</b></td>
+            <td>{expiry_html}</td>
+            <td style="color:{risk_color}; font-weight:bold;">{risk}</td>
+            <td>{carbon_html}</td>
+        </tr>
+        """
+
+    html += "</tbody></table>"
+    return html
+
+def format_meal_output(meal_plan_json):
+    import uuid
+
+    if isinstance(meal_plan_json, str):
+        try:
+            meal_plan_json = json.loads(meal_plan_json)
+        except json.JSONDecodeError:
+            return "<div style='color: red;'>Invalid meal plan format.</div>"
+
+    combined_text = ""
+    for block in meal_plan_json:
+        for val in block.values():
+            if isinstance(val, str):
+                combined_text += "\n" + val
+
+    sections = {
+        "b": {"title": "🌍 Carbon Footprint Overview", "content": ""},
+        "c": {"title": "📋 Suggested Meals", "content": ""},
+        "d": {"title": "🔁 Alternative Ingredients", "content": ""},
+        "e": {"title": "🧠 Reducing Waste & Emissions", "content": ""}
+    }
+
+    matches = re.findall(r"### \((b|c|d|e)\) (.+?)\n(.*?)(?=\n### \(|\Z)", combined_text, re.DOTALL)
+    for code, heading, content in matches:
+        if code in sections:
+            sections[code]["content"] = content.strip()
+
+    # Dark-mode accordion style
+    style = """
+    <style>
+        .accordion {
+            background-color: #121212;
+            border-radius: 8px;
+            margin-bottom: 10px;
+            border: 1px solid #333;
+            overflow: hidden;
+        }
+        .accordion summary {
+            font-weight: bold;
+            cursor: pointer;
+            padding: 15px;
+            font-size: 1.1rem;
+            background: #1e1e1e;
+            color: #fff;
+        }
+        .accordion p {
+            padding: 15px;
+            margin: 0;
+            background: #1a1a1a;
+            color: #ddd;
+            line-height: 1.6;
+        }
+    </style>
+    """
+
+    html_parts = []
+    for sec in ["b", "c", "d", "e"]:
+        content = sections[sec]["content"]
+        if not content:
+            continue
+        content_html = content.replace("\n", "<br>")
+        html_parts.append(f"""
+        <details class="accordion">
+            <summary>{sections[sec]["title"]}</summary>
+            <p>{content_html}</p>
+        </details>
+        """)
+
+    return style + "\n".join(html_parts)
+
+def combined_output_func(text, api_key):
+    status_text = "⏳ Processing..."
+    
+    parsed = handle_tool_call("parse_ingredients", {"text": text})
+    spoilage = handle_tool_call("predict_spoilage", {"items": parsed})
+    carbon = handle_tool_call("estimate_carbon", {"items": parsed})
+
+    items_with_risk = [
+        {**item, "risk": spoilage[i]} for i, item in enumerate(parsed)
+    ]
+
+    meal_plan = handle_tool_call(
+        "generate_meal_plan",
+        {
+            "items": items_with_risk,
+            "spoilage": spoilage,
+            "carbon": carbon,
+            "parsed": parsed,
+            "api_key": api_key
+        }
+    )
+
+    # Check for connection error inside 'recipes'
+    if (
+        isinstance(meal_plan, list) and
+        len(meal_plan) >= 2 and
+        isinstance(meal_plan[1], dict) and
+        "recipes" in meal_plan[1] and
+        meal_plan[1]["recipes"] == ['Error generating recipes: Connection error.']
+    ):
+        status_text = "❌ Connection error: Please input correct API key"
+        error_html = """
+        <div style="background-color: #ffdddd; color: #900; padding: 16px; margin-bottom: 20px; border-left: 6px solid #f44336; border-radius: 6px;">
+            ⚠️ <strong>Connection error:</strong> Please input a correct Nebius API key and try again.
+        </div>
+        """
+        return status_text, error_html
+
+    else:
+        status_text = "✅ Success! EcoChef has generated your meal plan and sustainability report."
+        success_banner = """
+        <div style="background-color: #ddffdd; color: #064b1a; padding: 16px; margin-bottom: 20px; border-left: 6px solid #4CAF50; border-radius: 6px;">
+            🌱 <strong>Success!</strong> Your meal plan and carbon footprint report have been generated.
+        </div>
+        """
+
+        if isinstance(meal_plan, str):
+            try:
+                meal_plan = json.loads(meal_plan)
+            except json.JSONDecodeError:
+                meal_plan = []
+
+        table_html = format_items_table(meal_plan)
+        meal_html = format_meal_output(meal_plan)
+
+        full_html = f"""
+        {success_banner}
+        {table_html}
+        <hr style="margin:40px 0; border-top: 2px solid #ccc;">
+        {meal_html}
+        """
+
+        return status_text, full_html
+
+    # Continue as usual if no error
+    if isinstance(meal_plan, str):
+        try:
+            meal_plan = json.loads(meal_plan)
+        except json.JSONDecodeError:
+            meal_plan = []
+
+    status_text = "✅ Done!"
+    table_html = format_items_table(meal_plan)
+    meal_html = format_meal_output(meal_plan)
+
+    full_html = f"""
+    {table_html}
+    <hr style="margin:40px 0; border-top: 2px solid #ccc;">
+    {meal_html}
+    """
+    return status_text, full_html
+
+# --- Gradio UI ---
+with gr.Blocks(title="EcoChef Dashboard", theme=gr.themes.Base(primary_hue="green", secondary_hue="blue")) as demo:
+    gr.Markdown("# 🥗 **EcoChef — Eco-Friendly AI Meal Planner with Food Carbon Insights**")
+    gr.Markdown("> _Reduce food waste. Eat smarter and Save the planet._")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            user_input = gr.Textbox(
+                lines=4,
+                placeholder="e.g. 2 bananas, LOBSTER, 6 eggs, rice, lentils",
+                value="Bananas 2, Lobsters 2, rice 1kg, lentils 500gm, yogurt expiring on 12th june, pasta expiring on 20th june",
+                label="🧊 What's in your fridge or pantry?"
+            )
+            gr.Markdown("_Note: **You may add expiry date of a product as: expiring on**_")
+
+            nebius_key_input = gr.Textbox(
+                placeholder="Paste your Nebius AI API key here...",
+                label="🔐 Enter Nebius AI API Key",
+                type="password"
+            )
+            submit_btn = gr.Button("✨ Analyze Ingredients")
+            status = gr.Markdown("⏳", visible=False)
+
+            gr.Markdown(" Carbon footprint data taken from the SU-EATABLE LIFE dataset.")
+            gr.Markdown(" 🤖 Created for Gradio Agents & MCP Hackathon 2025")
+
+        with gr.Column(scale=2):
+            combined_output = gr.HTML(label="Ingredients & Meal Plan")
+        
+    submit_btn.click(
+        combined_output_func,
+        inputs=[user_input, nebius_key_input],
+        outputs=[status, combined_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

carbon_model.py

@@ -0,0 +1,41 @@
+import pandas as pd
+from rapidfuzz import process, fuzz
+
+# Load Excel sheet once
+excel_path = "SuEatableLife_Food_Fooprint_database.xlsx"
+sheet_name = "SEL CF for users"
+
+df = pd.read_excel(excel_path, sheet_name=sheet_name, engine='openpyxl')
+
+# Clean column names
+df.columns = df.columns.str.strip()
+
+# Define lookup column and value column
+item_col = "Food commodity ITEM"
+carbon_col = "Carbon Footprint kg CO2eq/kg or l of food ITEM"
+
+# Drop rows with missing values
+df = df[[item_col, carbon_col]].dropna()
+
+# Prepare choices
+choices = df[item_col].str.lower().tolist()
+data = df.to_dict(orient="records")
+
+# Main function to estimate carbon footprint
+def estimate_carbon(item, data_lookup=data, top_n=3, score_threshold=80):
+    name = item.get("name", "").strip().lower()
+
+    top_matches = process.extract(name, choices, scorer=fuzz.token_set_ratio, limit=top_n)
+
+    for matched_name, score, match_index in top_matches:
+        if score >= score_threshold:
+            match = data_lookup[match_index]
+            return {
+                "name": item["name"],
+                "estimated_kg_CO2e_per_kg": match.get(carbon_col, "unknown")
+            }
+
+    return {
+        "name": item["name"],
+        "estimated_kg_CO2e_per_kg": "unknown"
+    }

mcp_server.py

@@ -0,0 +1,62 @@
+# mcp_server.py
+import sys
+import json
+import pandas as pd
+from parser import parse_ingredients
+from spoilage_model import predict_spoilage
+from carbon_model import estimate_carbon
+from meal_planner import generate_meal_plan
+
+# Load Excel dataset for carbon model once
+carbon_df = pd.read_excel("SuEatableLife_Food_Fooprint_database.xlsx", sheet_name=0)
+carbon_data = carbon_df.to_dict(orient="records")
+
+def handle_tool_call(tool_name, arguments):
+    if tool_name == "parse_ingredients":
+        user_input = arguments.get("text", "")
+        return parse_ingredients(user_input)
+
+    elif tool_name == "predict_spoilage":
+        items = arguments.get("items", [])
+        return predict_spoilage(items)
+
+    elif tool_name == "estimate_carbon":
+        items = arguments.get("items", [])
+        return [estimate_carbon(item, carbon_data) for item in items]
+
+    elif tool_name == "generate_meal_plan":
+        items = arguments.get("items", [])
+        spoilage = arguments.get("spoilage", [])
+        carbon = arguments.get("carbon", [])
+        parsed = arguments.get("parsed", [])
+        api_key = arguments.get("api_key", []) # api key
+        return generate_meal_plan(items, spoilage, carbon, parsed, api_key)
+
+    else:
+        return {"error": f"Unknown tool: {tool_name}"}
+
+def main():
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            break
+        try:
+            request = json.loads(line)
+            tool_name = request.get("tool")
+            arguments = request.get("input", {})
+
+            result = handle_tool_call(tool_name, arguments)
+            response = {
+                "id": request.get("id"),
+                "output": result,
+            }
+            print(json.dumps(response), flush=True)
+
+        except Exception as e:
+            error_response = {
+                "error": str(e)
+            }
+            print(json.dumps(error_response), flush=True)
+
+if __name__ == "__main__":
+    main()

meal_planner.py

@@ -0,0 +1,142 @@
+import os
+from openai import OpenAI
+import json
+
+def call_llm(prompt, api_key):
+    try:
+        client = OpenAI(
+            base_url="https://api.studio.nebius.com/v1/",
+            api_key=api_key
+        )
+        response = client.chat.completions.create(
+            model="meta-llama/Llama-3.3-70B-Instruct",
+            max_tokens=1024,
+            temperature=0.6,
+            top_p=0.9,
+            extra_body={"top_k": 50},
+            messages=[
+                {
+                    "role": "system",
+                    "content": """You are an eco-conscious recipe planner. Use the provided ingredient data to minimize food waste and carbon footprint.
+
+### Instructions:
+1. Provide json values with the following keys for given data:
+  • Ingredient (Qty: if specified)
+  • Expiry / Shelf Life (use 'X days left' if available, else 'Unknown')
+  • Spoilage Risk (high, medium, low — assume only if missing)
+  • Carbon Footprint (kg CO₂e/kg — assume only if missing)
+- Only assume values **if the field is null or missing**, and **only if the ingredient is a known food item**.
+- When assuming missing values, refer to other similar ingredients in the data as examples for expected format and typical values.
+- Fields eligible for assumption (only under above condition):
+  • spoilage → risk
+  • carbon → estimated_kg_CO2e_per_kg
+  • parsed → days_left
+- Use all other values exactly as provided without change.
+2. Summary of carbon footprint based on provided ingredients in friendly tone.
+3. Provide new 2-3 simple recipe ideas (bulleted or numbered) for ingredients focusing more on high risk to reduce food spoilage. Keep recipes simple, using common household ingredients and easy steps. Give everything as JSON format.
+4. Present your answer in clear sections as below: 
+    (a) Json ingredients table with all data.
+    (b) Carbon footprint overview and impact of ingredients present in json data.
+    (c) Suggested meals to reduce food spoilage: i. recipe name, ii. ingredients, iii. preparation steps
+    (d) Alternative ingredients to reduce carbon emissions from your fridge/pantry (if possible). Also, If possible suggest ingredient substitutions reasons (e.g. high carbon footprint).
+    (e) End with single sentence why and how your recomendation reduces food wastage and also helps user carbon emissions. give appropriate examples with slight pun (like might save trips to some destination)"""
+                },
+                {
+                    "role": "user",
+                    "content": prompt  # ← Inject user-provided ingredient data here
+                }
+            ]
+        )
+
+        parsed_json = json.loads(response.to_json())
+
+        # Extract the 'content' safely
+        try:
+            content = parsed_json["choices"][0]["message"]["content"]
+        except (KeyError, IndexError) as e:
+            content = None
+            print("Failed to get content from LLM:", e)
+
+        return content
+
+    except Exception as e:
+        return [f"Error generating recipes: {str(e)}"]
+
+# === LLM-powered meal planner ===
+def generate_meal_plan(parsed_items, spoilage, carbon, parsed, api_key):
+    if not parsed_items:
+        return [{"note": "No ingredients found to suggest recipes."}]
+
+    parsed_names = [item.get("name", "").lower() for item in parsed_items]
+    spoilage_dict = {item["name"].lower(): item["risk"].lower() for item in spoilage}
+    carbon_dict = {
+        item["name"].lower(): item.get("estimated_kg_CO2e_per_kg", "unknown") 
+        for item in carbon
+    }
+
+    # Categorize by spoilage risk
+    high_risk = [name for name in parsed_names if spoilage_dict.get(name) == "high"]
+    medium_risk = [name for name in parsed_names if spoilage_dict.get(name) == "medium"]
+    low_risk = [name for name in parsed_names if spoilage_dict.get(name) == "low"]
+
+    # Construct note with carbon footprint
+    def format_item(name, risk_level):
+        co2e = carbon_dict.get(name, "unknown")
+        return f"- {name.title()} (Risk: {risk_level.title()}, CO₂e: {co2e} kg/kg)"
+
+    note_lines = ["Suggesting recipes based on spoilage risk:"]
+    for name in high_risk:
+        note_lines.append(format_item(name, "high"))
+    for name in medium_risk:
+        note_lines.append(format_item(name, "medium"))
+    for name in low_risk:
+        note_lines.append(format_item(name, "low"))
+    if not high_risk and not medium_risk:
+        note_lines.append("- No items at spoilage risk. Showing general ideas.")
+
+    # Format CO2 label with risk
+    def co2_label(name):
+        co2 = carbon_dict.get(name, "unknown")
+        return f"{name} (CO₂e: {co2} kg/kg)"
+
+    # Add detailed ingredient info from 'parsed'
+    parsed_ingredient_info = "Ingredient details:\n"
+    for item in parsed:
+        name = item.get("name", "unknown").strip().lower()
+        qty = item.get("quantity", "unknown")
+        expiry = item.get("expiry_date", "unknown")
+        days_left = item.get("days_left")
+
+    parsed_ingredient_info += (
+        f"- {name.title()}: Quantity = {qty}, "
+        f"Expiry Date = {expiry}, Days Left = {days_left}\n"
+    )
+
+    # Construct prompt with all context
+    prompt = (
+        "You are an eco-conscious recipe planner. Use the provided ingredient data to minimize food waste and carbon footprint.\n\n"
+        "### Data for processing is as follows:\n"
+        "- Spoilage info:\n"
+        f"{json.dumps(spoilage, indent=2)}\n\n"
+        "- Carbon footprint info:\n"
+        f"{json.dumps(carbon, indent=2)}\n\n"
+        "- Parsed ingredient details:\n"
+        f"{json.dumps(parsed, indent=2)}\n\n"
+    )
+
+    recipes = call_llm(prompt, api_key)
+
+    note_lines = ["Suggesting recipes based on spoilage risk and carbon footprint:"]
+    for name in high_risk:
+        cf = carbon_dict.get(name, "N/A")
+        note_lines.append(f"- {name.title()} (Risk: High, CO₂e: {cf} kg/kg)")
+    for name in medium_risk:
+        cf = carbon_dict.get(name, "N/A")
+        note_lines.append(f"- {name.title()} (Risk: Medium, CO₂e: {cf} kg/kg)")
+    if not high_risk and not medium_risk:
+        note_lines.append("- No items at spoilage risk. Showing general ideas.")
+
+    return [
+        {"note": "\n".join(note_lines)},
+        {"recipes": recipes}
+    ]

parser.py

@@ -0,0 +1,71 @@
+import dateparser
+import re
+from datetime import datetime
+import json
+import os
+import inflect
+
+# Load shelf life data from spoilage.json
+with open("spoilage_data.json", "r") as f:
+    shelf_life_data = json.load(f)
+
+p = inflect.engine()
+
+def parse_ingredients(text):
+    lines = [item.strip() for item in text.split(',')]
+    parsed = []
+
+    for line in lines:
+        raw_line = line
+        expiry = None
+        expiry_phrase = None
+        quantity = "1"
+        unit = ""
+
+        # Extract expiry phrase
+        keywords = r"(?:expiring|expire|exp|exp dt|expiration date|use by|best before|by|from|on)"
+        expiry_match = re.search(rf'\b{keywords}\b\s*(.*)', line, flags=re.IGNORECASE)
+
+        if expiry_match:
+            expiry_phrase = expiry_match.group(0)
+            possible_date_str = expiry_match.group(1)
+            maybe_date = dateparser.parse(possible_date_str)
+            if maybe_date:
+                expiry = maybe_date.date()
+                line = line.replace(expiry_phrase, '').strip()
+
+        # Extract quantity + unit + name
+        match = re.match(r"(?:(\d+)\s*([a-zA-Z]+)?\s+([a-zA-Z ]+))|([a-zA-Z ]+)\s+(\d+)([a-zA-Z]*)", line)
+        if match:
+            if match.group(1):
+                quantity = match.group(1)
+                unit = match.group(2) or ""
+                name_clean = match.group(3).strip()
+            elif match.group(4):
+                name_clean = match.group(4).strip()
+                quantity = match.group(5)
+                unit = match.group(6) or ""
+        else:
+            name_clean = re.sub(r'\d+.*', '', line).strip()
+
+        # Calculate days left
+        if expiry:
+            days_left = (expiry - datetime.today().date()).days
+        else:
+            # Estimate from shelf life data
+            shelf_key = name_clean.lower()
+            singular_key = p.singular_noun(shelf_key) or shelf_key
+            shelf_life = shelf_life_data.get(shelf_key) or shelf_life_data.get(singular_key)
+            days_left = shelf_life if isinstance(shelf_life, int) else None
+
+        parsed.append({
+            "raw": raw_line,
+            "name": name_clean.lower(),
+            "quantity": quantity,
+            "unit": unit.lower(),
+            "expiry_date": expiry.isoformat() if expiry else None,
+            "days_left": days_left,
+            "note": "ok"
+        })
+
+    return parsed

requirements.txt

@@ -0,0 +1,7 @@
+openai
+gradio
+dateparser
+inflect
+pandas
+rapidfuzz
+openpyxl

spoilage_data.json

@@ -0,0 +1,323 @@
+{
+    "buffalo bone free meat": 3,
+    "beef bone free meat": 3,
+    "lamb bone free meat": 3,
+    "lobster": 2,
+    "beef meat with bone": 3,
+    "pork sausages": 2,
+    "pecorino": 30,
+    "lamb meat with bone": 3,
+    "grana padano": 30,
+    "prawns shrimps f": 2,
+    "turbot": 2,
+    "sole f": 2,
+    "megrim": 2,
+    "swordfish": 2,
+    "parmigiano reggiano": 30,
+    "anglerfish": 2,
+    "porbeagle": 2,
+    "shark": 2,
+    "ceddar": 30,
+    "hake": 2,
+    "asiago": 30,
+    "cheese": 30,
+    "catfish": 2,
+    "cheese semi-hard": 30,
+    "butter": 30,
+    "rhombus": 2,
+    "goat cheese": 20,
+    "coffee parchment": 180,
+    "mozzarella": 7,
+    "emmental": 30,
+    "fork beard": 2,
+    "pork ham": 10,
+    "octopus f": 2,
+    "camembert": 14,
+    "raspberry g": 3,
+    "prawns shrimps": 2,
+    "rock fish": 2,
+    "squid": 2,
+    "pomfret": 2,
+    "chocolate": 60,
+    "ling": 2,
+    "flatfish": 2,
+    "plaice": 2,
+    "diamond fish": 2,
+    "octopus": 2,
+    "pork bone free meat": 3,
+    "mascarpone": 7,
+    "krill": 2,
+    "cream": 7,
+    "sole": 2,
+    "coffee ground": 180,
+    "cuttlefish": 2,
+    "fish mixed": 2,
+    "stracchino": 14,
+    "almond covered with chocolate": 60,
+    "trout f": 2,
+    "rabbit meat with bone": 3,
+    "vanilla": 90,
+    "trout": 2,
+    "kangaroo meat": 3,
+    "duck meat bone free": 3,
+    "turkey meat bone free": 3,
+    "bacon": 7,
+    "neck": 3,
+    "eel": 2,
+    "pepper g": 7,
+    "haddock f": 2,
+    "chicken bone free meat": 3,
+    "tuna": 2,
+    "milk chocolate": 60,
+    "sea-bass": 2,
+    "buffalo milk": 7,
+    "alfonsino": 2,
+    "yogurt lactose free": 14,
+    "pork meat with bone": 3,
+    "hazelnut covered with chocolate": 60,
+    "ricotta": 7,
+    "salmon": 2,
+    "yeast dried": 180,
+    "olive oil": 180,
+    "fig juice i": 5,
+    "eggs": 21,
+    "egg pasta": 3,
+    "haddock": 2,
+    "cod": 2,
+    "cod f": 2,
+    "blueberry juice i": 5,
+    "almond paste": 90,
+    "mango juice i": 5,
+    "eggplant g": 7,
+    "peanut oil": 180,
+    "strawberry g": 3,
+    "cranberry juice i": 5,
+    "yogurt flavoured": 14,
+    "apple juice i": 5,
+    "kiwi juice i": 5,
+    "mealworms": 3,
+    "chicken meat with bone": 3,
+    "pineapple juice i": 5,
+    "green beans f": 5,
+    "pesto without garlic": 7,
+    "pesto": 7,
+    "dark chocolate": 60,
+    "hazelnut cream": 60,
+    "strawberry juice i": 5,
+    "lettuce g": 5,
+    "whiting": 2,
+    "cornflakes": 180,
+    "tuna f": 2,
+    "flathead": 2,
+    "quorne": 7,
+    "palm oil": 180,
+    "exotic fruit g": 5,
+    "exotic fruit i": 5,
+    "tomato g": 7,
+    "barnacle": 2,
+    "tofu": 7,
+    "fish stick f": 2,
+    "rice": 180,
+    "pollock stick f": 2,
+    "cod fish stick": 2,
+    "hake fish stick": 2,
+    "cakes and croissant": 3,
+    "turkey meat with bone": 3,
+    "gerkin g": 7,
+    "tuna in can": 180,
+    "duck meat with bone": 3,
+    "mushroom": 7,
+    "walnut": 90,
+    "mayonnaise": 14,
+    "buckwheat flour": 180,
+    "cocoa cakes and croissant": 3,
+    "almond": 90,
+    "peanut paste": 90,
+    "mackerel": 2,
+    "soybean oil": 180,
+    "rapeseed oil": 180,
+    "coconut i": 90,
+    "zucchini g": 7,
+    "beans f": 5,
+    "carp": 2,
+    "honey": 365,
+    "yogurt white": 14,
+    "hazelnut paste": 90,
+    "soy cream": 14,
+    "salmon f": 2,
+    "carrots canned": 180,
+    "pistachio": 90,
+    "chocolate or cream filled cookies": 60,
+    "emu bone free meat": 3,
+    "mung bean flour": 180,
+    "soy burger": 7,
+    "tomato chopped": 7,
+    "ketchup": 180,
+    "green beans in can": 180,
+    "goat milk": 7,
+    "melon g": 5,
+    "pollock": 2,
+    "simple cookies": 60,
+    "margarine": 30,
+    "cashew nut": 90,
+    "millet flour": 180,
+    "soy yogurt": 14,
+    "corn canned": 180,
+    "zucchini f": 7,
+    "plain crackers": 180,
+    "crispbread": 180,
+    "sorghum flour": 180,
+    "azuki bean flour": 180,
+    "bread frozen f": 30,
+    "maize flour": 180,
+    "cow milk": 7,
+    "tomato peeled": 7,
+    "herring f": 2,
+    "tomato arrabbiata": 7,
+    "herring": 2,
+    "pasta": 7,
+    "raspberries f": 3,
+    "pomegranate i": 5,
+    "sunflower seed": 90,
+    "peanut butter": 90,
+    "tomato basil": 7,
+    "hazelnut": 90,
+    "carrob": 7,
+    "tempe": 7,
+    "pilchard": 2,
+    "avocado i": 5,
+    "mixed fish f": 2,
+    "tomato puree": 7,
+    "lentil": 180,
+    "ice cream": 7,
+    "makerel fish stick": 2,
+    "mackerel f": 2,
+    "sunflower oil": 180,
+    "quinoa": 180,
+    "wholegrain crackers": 180,
+    "beer in glass": 180,
+    "beet sugar": 365,
+    "flavored crackers": 180,
+    "sardine": 2,
+    "pollock f": 2,
+    "bread plain": 30,
+    "sorghum": 180,
+    "sesam seed": 90,
+    "ginger": 180,
+    "wine red": 180,
+    "oat meal": 180,
+    "cranberry": 5,
+    "millet": 180,
+    "gooseberry": 5,
+    "strawberry i": 3,
+    "peanut": 90,
+    "asparagus": 5,
+    "yeast compressed": 21,
+    "anchovy": 2,
+    "banana i": 5,
+    "raisin": 180,
+    "palm nut": 90,
+    "chilly": 180,
+    "rape seed": 180,
+    "soy milk": 7,
+    "blueberry": 5,
+    "bread whole": 30,
+    "chickpea": 180,
+    "snails": 3,
+    "garlic": 180,
+    "bread multicereal": 30,
+    "zucchini": 7,
+    "beer in can": 180,
+    "oat": 180,
+    "rice milk": 7,
+    "pepper": 7,
+    "currant": 5,
+    "olives": 90,
+    "raspberry": 3,
+    "cane sugar": 365,
+    "soy meal": 180,
+    "melon": 5,
+    "strawberry": 3,
+    "date": 180,
+    "coffee drip filtered l": 180,
+    "wheat": 180,
+    "broccoli": 5,
+    "soybean": 180,
+    "espresso l": 180,
+    "pineapple i": 5,
+    "avocado": 5,
+    "vegetables": 7,
+    "beer modular can": 180,
+    "wheat plain flour": 180,
+    "watermelon": 5,
+    "green bean fresh": 5,
+    "pomelo": 5,
+    "yeast liquid": 21,
+    "kiwi": 5,
+    "mineral water": 180,
+    "pear juice": 5,
+    "coffee green": 180,
+    "cowpea": 180,
+    "barley": 180,
+    "maize": 180,
+    "fennel": 7,
+    "graham flour": 180,
+    "mixed nuts": 90,
+    "durum wheat": 180,
+    "mussels": 2,
+    "orange juice": 5,
+    "cherry": 5,
+    "tomato": 7,
+    "mandarin": 5,
+    "pea": 180,
+    "wine white": 180,
+    "chestnut": 90,
+    "bean": 180,
+    "blackberry": 3,
+    "almond milk": 7,
+    "coconut milk": 7,
+    "lettuce": 5,
+    "clementine": 5,
+    "rockmelon": 5,
+    "peach": 5,
+    "tangerin": 5,
+    "rye": 180,
+    "whole wheat flour": 180,
+    "turnip": 7,
+    "banana": 5,
+    "spinach": 5,
+    "coffee soluble powder l": 180,
+    "artichoke": 7,
+    "pomegranate": 5,
+    "cucumber g": 7,
+    "celery": 7,
+    "grapes": 5,
+    "mango": 5,
+    "cauliflower": 7,
+    "orange": 5,
+    "apricot": 5,
+    "starchy roots": 180,
+    "swede": 7,
+    "pineapple": 5,
+    "guava": 5,
+    "green bean fresh g": 5,
+    "pear": 5,
+    "sweet potato": 180,
+    "cucumber": 7,
+    "carrots f": 7,
+    "fig": 5,
+    "plum": 5,
+    "apple": 5,
+    "beetroot": 7,
+    "potato": 180,
+    "pumpkin": 7,
+    "carrot": 7,
+    "cabagge": 7,
+    "onion": 180,
+    "lemon": 7,
+    "lime": 7,
+    "gerkin": 7,
+    "eggplant": 7,
+    "radish": 7,
+    "beans in can": 180
+  }  

spoilage_model.py

@@ -0,0 +1,74 @@
+from datetime import datetime, date
+import json
+import os
+import re
+import inflect
+
+p = inflect.engine()
+SHELF_LIFE_DATA_PATH = "spoilage_data.json"
+
+if not os.path.exists(SHELF_LIFE_DATA_PATH):
+    raise FileNotFoundError(f"Could not find {SHELF_LIFE_DATA_PATH}")
+
+with open(SHELF_LIFE_DATA_PATH, "r") as f:
+    shelf_life_data = json.load(f)
+
+shelf_life_data = {k.lower().strip(): v for k, v in shelf_life_data.items()}
+
+def parse_expiry_date(date_str):
+    if not date_str:
+        return None
+    try:
+        return datetime.strptime(date_str, "%Y-%m-%d").date()
+    except ValueError:
+        pass
+    try:
+        dt = datetime.strptime(date_str, "%d %B")
+        return dt.replace(year=date.today().year).date()
+    except ValueError:
+        pass
+    return None
+
+def calculate_days_left(expiry_date):
+    if not expiry_date:
+        return None
+    return (expiry_date - date.today()).days
+
+def classify_spoilage_risk(days_left):
+    if days_left is None:
+        return "unknown"
+    if days_left < 0:
+        return "expired"
+    elif days_left <= 2:
+        return "high"
+    elif days_left <= 5:
+        return "medium"
+    else:
+        return "low"
+
+def singularize_name(name):
+    return " ".join([p.singular_noun(w) or w for w in name.split()])
+
+def predict_spoilage(items):
+    results = []
+    for item in items:
+        raw_name = item.get("name", "").lower().strip()
+        clean_name = re.sub(r'\d+.*', '', raw_name).strip()
+        singular_name = singularize_name(clean_name)
+
+        expiry_date_str = item.get("expiry_date")
+        expiry_date = parse_expiry_date(expiry_date_str)
+        days_left = calculate_days_left(expiry_date)
+
+        if days_left is None:
+            shelf_life = shelf_life_data.get(singular_name) or shelf_life_data.get(clean_name)
+            if isinstance(shelf_life, int):
+                days_left = shelf_life
+
+        risk = classify_spoilage_risk(days_left)
+        results.append({
+            "name": item.get("name", ""),
+            "risk": risk
+        })
+
+    return results