Add updated files

app.py

@@ -1,13 +1,18 @@
 import gradio as gr
 from transformers import pipeline
+import random
+from gtts import gTTS
+import os
+
+# Import your local modules (Ensure game_data.py, dialogues.py, alternatives.py exist in the same folder)
 from game_data import calculate_impact
+from dialogues import get_dialogue
+from alternatives import ALTERNATIVES
 
-# Load zero-shot classification pipeline 
-# (This runs server-side and uses the free CPU tier effectively)
+# --- 1. Load AI Models ---
 print("Loading classification model (facebook/bart-large-mnli)...")
 classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
 
-# Predefined categories mapping to your zero-shot labels
 CATEGORIES = [
     "simple factual question",
     "mathematical calculation",
@@ -15,43 +20,243 @@ CATEGORIES = [
     "complex research query"
 ]
 
-def classify_query(user_input):
+# --- 2. Helper Functions & UI Generators ---
+
+def generate_audio(text):
+    """Generates instant TTS audio using gTTS to prevent CPU timeouts."""
+    tts = gTTS(text, lang='en')
+    filepath = "temp_drip_voice.mp3"
+    tts.save(filepath)
+    return filepath
+
+def get_drip_visuals(water_level):
+    """Generates the CSS/HTML for Drip based on dehydration."""
+    if water_level > 70:
+        emoji, size, animation = "💧", "80px", "bounce 2s infinite"
+        status = "Plump & Hydrated"
+    elif 30 <= water_level <= 70:
+        emoji, size, animation = "💧", "60px", "none"
+        status = "Shrinking & Tired"
+    elif water_level > 0:
+        emoji, size, animation = "🏜️", "40px", "none"
+        status = "Cracked & Raspy"
+    else:
+        emoji, size, animation = "💨", "30px", "none"
+        status = "Evaporated!"
+        
+    return f"""
+    <div style="text-align: center; margin-bottom: 20px;">
+        <div style="font-size: {size}; animation: {animation}; transition: all 0.5s;">{emoji}</div>
+        <h3 style="margin: 0;">Drip Status: {status}</h3>
+    </div>
     """
-    Takes user input, classifies it using zero-shot classification, 
-    and returns the highest probability category and its confidence score.
+
+def get_impact_cards(impact, category):
+    """Generates side-by-side comparison cards."""
+    # Relatable translations
+    water_trans = f"{impact['water']}L is like leaving a tap running for {int(impact['water']*12)} seconds."
+    if impact['water'] >= 5:
+         water_trans = f"{impact['water']}L = A whole day's drinking water for a family."
+    
+    energy_trans = f"{impact['energy']}kWh could charge your phone {int(impact['energy']*100)} times."
+    if impact['energy'] >= 0.5:
+         energy_trans = f"{impact['energy']}kWh = Powering a fridge for several hours."
+
+    return f"""
+    <div style="display: flex; gap: 20px; justify-content: center; margin-top: 20px;">
+        <div style="flex: 1; padding: 15px; background: #ffebee; border-left: 5px solid #f44336; border-radius: 5px;">
+            <h3 style="color: #c62828; margin-top: 0;">LLM Impact (Massive Servers)</h3>
+            <p><strong>Water Wasted:</strong> {impact['water']}L</p>
+            <p><strong>Energy Wasted:</strong> {impact['energy']}kWh</p>
+            <p><em>{water_trans}</em></p>
+            <p><em>{energy_trans}</em></p>
+        </div>
+        <div style="flex: 1; padding: 15px; background: #e8f5e9; border-left: 5px solid #4caf50; border-radius: 5px;">
+            <h3 style="color: #2e7d32; margin-top: 0;">Eco-Alternative (Local/Search)</h3>
+            <p><strong>Water Wasted:</strong> ~0.0L</p>
+            <p><strong>Energy Wasted:</strong> ~0.001kWh</p>
+            <p><em>Save the planet, use appropriate tools!</em></p>
+        </div>
+    </div>
     """
-    result = classifier(user_input, CATEGORIES)
-    top_category = result['labels'][0]
-    confidence_score = result['scores'][0]
+
+def generate_report(state):
+    """Generates the final game over report."""
+    badges = []
+    if state['water'] > 50: badges.append("🌊 Water Warrior")
+    if state['eco_score'] >= 80: badges.append("🌿 Conscious Querier")
+    if not badges: badges.append("🔥 Resource Drainer")
     
-    return top_category, confidence_score
+    return f"""
+    <div style="background: #2c3e50; color: white; padding: 30px; border-radius: 10px; text-align: center;">
+        <h1>Game Over! Here is your AI Audit.</h1>
+        <h2>Final Score: {state['points']} Points</h2>
+        <p>You asked {state['queries']} queries.</p>
+        <p><strong>Total Water Drained:</strong> {100 - state['water']:.2f}L</p>
+        <p><strong>Total Energy Consumed:</strong> {state['energy']:.3f}kWh</p>
+        <p><strong>Eco-Score:</strong> {state['eco_score']:.1f}%</p>
+        <h3>Badges Earned:</h3>
+        <h2>{' | '.join(badges)}</h2>
+        <p style="margin-top: 20px; font-size: 0.9em;"><em>Tip: Match the tool to the task. Don't use a supercomputer to ask for a recipe! Review the UNESCO guidelines on proportional AI usage.</em></p>
+    </div>
+    """
 
-def process_query(user_input):
-    """Processes the query for the Gradio interface."""
-    category, confidence = classify_query(user_input)
+# --- 3. Core Game Logic ---
+
+def process_query(user_input, state):
+    if state["game_over"] or not user_input.strip():
+        return state, gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(visible=False), gr.update(visible=False)
+
+    # 1. Classification & Impact Calculation
+    result = classifier(user_input, CATEGORIES)
+    category = result['labels'][0]
+    confidence = result['scores'][0]
+    
     impact = calculate_impact(category, confidence, user_input)
     
-    result_text = (
-        f"**Category:** {category}\n"
-        f"**Confidence:** {confidence:.2f}\n"
-        f"**Water Wasted:** {impact['water']}L\n"
-        f"**Energy Wasted:** {impact['energy']}kWh"
-    )
-    return result_text
+    # 2. Update Basic State
+    state["queries"] += 1
+    state["water"] = max(0, state["water"] - impact["water"])
+    state["energy"] += impact["energy"]
+    state["history"].append(category)
 
-# Create a basic Gradio interface to keep the Space alive
-with gr.Blocks() as demo:
-    gr.Markdown("# 💧 EcoQueryQuest (Test UI)")
-    gr.Markdown("Type a query to see its hidden environmental cost!")
+    # 3. Category Specific Logic (Points & Alternatives)
+    show_alts = False
+    alt_choices = []
+    correct_alt = None
     
-    with gr.Row():
-        input_box = gr.Textbox(label="Your Query", placeholder="e.g., What is the capital of France?")
+    if category == "complex research query":
+        # Justified use: +50 points, no alternatives needed
+        state["points"] += 50
+        dialogue = "Finally, a real question! This is what my servers were built for. Draining, but worth it."
+    else:
+        # Unjustified/Avoidable: Fetch alternatives
+        show_alts = True
+        alt_choices = ALTERNATIVES.get(category, ["Google", "Wikipedia", "Book"])
+        correct_alt = alt_choices[0] # For MVP, the first item in the list is the "best" one
+        random.shuffle(alt_choices) # Shuffle so it's not always button 1
+        state["current_best_alt"] = correct_alt
+        
+        # Get sarcastic Drip dialogue based on water level
+        dialogue = get_dialogue(state["water"], category)
+
+    # 4. Generate outputs
+    drip_ui = get_drip_visuals(state["water"])
+    impact_ui = get_impact_cards(impact, category)
+    audio_path = generate_audio(dialogue)
+    
+    # Check Win/Loss
+    if state["points"] >= 500 or state["water"] <= 0:
+        state["game_over"] = True
+        return (state, drip_ui, gr.update(value=state["water"]), gr.update(value=f"{state['energy']:.3f} kWh"), 
+                generate_report(state), gr.update(visible=False), audio_path, gr.update(visible=False), gr.update(visible=False))
+
+    # Return updated UI components
+    if show_alts:
+        return (state, drip_ui, gr.update(value=state["water"]), gr.update(value=f"{state['energy']:.3f} kWh"), 
+                impact_ui, gr.update(value=f"**{category.upper()}** Detected! {dialogue}"), audio_path, 
+                gr.update(visible=True), gr.update(value=alt_choices[0]), gr.update(value=alt_choices[1]), gr.update(value=alt_choices[2]))
+    else:
+        return (state, drip_ui, gr.update(value=state["water"]), gr.update(value=f"{state['energy']:.3f} kWh"), 
+                impact_ui, gr.update(value=f"**{category.upper()}** Detected! {dialogue}"), audio_path, 
+                gr.update(visible=False), gr.update(), gr.update(), gr.update())
+
+
+def select_alternative(choice, state):
+    """Handles logic when a user clicks an Eco-Alternative button."""
+    if state["game_over"] or not state.get("current_best_alt"):
+        return state, gr.update()
+        
+    msg = ""
+    if choice == state["current_best_alt"]:
+        state["points"] += 10
+        state["eco_choices"] += 1
+        msg = "✅ **Great choice!** You earned +10 Eco Points for picking the right tool for the job."
+    else:
+        msg = "❌ **Not quite.** That works, but there was a better eco-friendly option. Still better than an LLM though!"
     
-    submit_btn = gr.Button("Analyze")
-    output_box = gr.Markdown(label="Impact Results")
+    # Update Eco-Score
+    state["eco_score"] = (state["eco_choices"] / state["queries"]) * 100 if state["queries"] > 0 else 0
     
-    submit_btn.click(fn=process_query, inputs=input_box, outputs=output_box)
+    # Hide alternatives after selection
+    return state, gr.update(value=msg), gr.update(visible=False)
+
+
+# --- 4. Gradio Interface Layout ---
+
+custom_css = """
+.gradio-container { max-width: 800px !important; margin: auto; }
+.progress-bar-container { background: #e0e0e0; border-radius: 10px; height: 30px; width: 100%; overflow: hidden; margin-top: 5px; }
+.progress-bar { background: #2196f3; height: 100%; transition: width 0.5s ease-in-out; }
+"""
+
+with gr.Blocks(css=custom_css, title="EcoQueryQuest") as demo:
+    
+    # Initialize Game State
+    game_state = gr.State({
+        "water": 100.0, "energy": 0.0, "points": 0, "queries": 0, 
+        "eco_choices": 0, "eco_score": 0.0, "history": [], "game_over": False,
+        "current_best_alt": None
+    })
+
+    gr.Markdown("# 🌍 EcoQueryQuest")
+    gr.Markdown("Type your query below. Watch Drip (💧) react to the environmental cost of your prompt! Reach 500 points to win, but don't run out of water.")
+
+    # TOP SECTION: Visuals & Trackers
+    with gr.Row():
+        with gr.Column(scale=1):
+            drip_html = gr.HTML(get_drip_visuals(100))
+        with gr.Column(scale=2):
+            gr.Markdown("### 🚰 Water Tank (100L Limit)")
+            water_slider = gr.Slider(minimum=0, maximum=100, value=100, interactive=False, show_label=False)
+            gr.Markdown("### ⚡ Energy Wasted")
+            energy_text = gr.Textbox(value="0.000 kWh", interactive=False, show_label=False)
+            gr.Markdown("### 🏆 Points")
+            points_text = gr.Textbox(value="0", interactive=False, show_label=False)
+
+    # MIDDLE SECTION: Interaction
+    with gr.Group() as interaction_group:
+        user_input = gr.Textbox(label="Ask an AI a question...", placeholder="e.g., What is 25 * 42? or Write me a poem about dogs.")
+        submit_btn = gr.Button("Send Query", variant="primary")
+        
+    main_display_html = gr.HTML()
+    drip_dialogue_text = gr.Markdown()
+    drip_audio = gr.Audio(label="Drip's Reaction", autoplay=True, interactive=False)
+
+    # BOTTOM SECTION: Alternatives (Hidden by default)
+    with gr.Group(visible=False) as alternatives_group:
+        gr.Markdown("### ⏳ Drip says: 'Choose a better alternative to save me!'")
+        with gr.Row():
+            alt_btn_1 = gr.Button("Alt 1")
+            alt_btn_2 = gr.Button("Alt 2")
+            alt_btn_3 = gr.Button("Alt 3")
+        alt_feedback = gr.Markdown()
+
+    # EVENT WIRING
+    
+    # 1. Submit Query
+    submit_btn.click(
+        fn=process_query,
+        inputs=[user_input, game_state],
+        outputs=[game_state, drip_html, water_slider, energy_text, main_display_html, drip_dialogue_text, drip_audio, alternatives_group, alt_btn_1, alt_btn_2, alt_btn_3]
+    ).then(
+        fn=lambda s: gr.update(value=str(s["points"])), # Update points UI after processing
+        inputs=[game_state],
+        outputs=[points_text]
+    )
+
+    # 2. Click Alternative Buttons
+    for btn in [alt_btn_1, alt_btn_2, alt_btn_3]:
+        btn.click(
+            fn=select_alternative,
+            inputs=[btn, game_state],
+            outputs=[game_state, alt_feedback, alternatives_group]
+        ).then(
+            fn=lambda s: gr.update(value=str(s["points"])), # Update points UI after clicking alternative
+            inputs=[game_state],
+            outputs=[points_text]
+        )
 
-# Launch the app so it stays running on Hugging Face
+# Launch the app
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,4 +1,5 @@
 gradio
 transformers
 torch
-Pillow
+Pillow
+gTTS