Update app.py

app.py

@@ -1,65 +1,155 @@
+import os
 import gradio as gr
-from langdetect import detect
-from deep_translator import GoogleTranslator
-import random
-
-# Sample phrases
-phrases = {
-    "easy": [
-        "I love learning new languages.",
-        "The sun is shining brightly.",
-        "Books are windows to the world."
-    ],
-    "medium": [
-        "Curiosity is the wick in the candle of learning.",
-        "Technology connects the world in real time.",
-        "Imagination is the beginning of creation."
-    ],
-    "hard": [
-        "Philosophy begins in wonder and ends in understanding.",
-        "The subconscious mind is a powerful force.",
-        "Language is the roadmap of a culture."
-    ]
+import speech_recognition as sr
+import numpy as np
+import tempfile
+import scipy.io.wavfile
+import requests
+
+# API key setup
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+# Game session
+state = {
+    "started": False,
+    "history": [],
+    "current_q": "",
+    "question_num": 0,
+    "hint_mode": False
 }
 
-# State
-current_phrase = None
-selected_lang = None
-
-def start_game(difficulty):
-    global current_phrase, selected_lang
-    current_phrase = random.choice(phrases[difficulty])
-    detected = detect(current_phrase)
-    selected_lang = random.choice(['es', 'fr', 'de', 'hi', 'ur', 'ar'])
-    translated = GoogleTranslator(source='en', target=selected_lang).translate(current_phrase)
-    return translated, "Try guessing what this means in English!"
-
-def check_guess(user_guess):
-    if not current_phrase:
-        return "Click 'Start Game' first!"
-    if user_guess.strip().lower() == current_phrase.strip().lower():
-        return f"✅ Correct! It was: '{current_phrase}'"
-    else:
-        return f"❌ Incorrect! Try again!"
-
-with gr.Blocks() as demo:
-    gr.Markdown("## 🌍 Language Guess Game - Remix Edition")
+# ---- AUDIO ----
+def convert_audio_to_text(audio, lang_choice):
+    if audio is None:
+        return ""
 
-    with gr.Row():
-        difficulty = gr.Radio(["easy", "medium", "hard"], label="Select Difficulty")
-        start_btn = gr.Button("🎮 Start Game")
+    try:
+        sr_rate, audio_data = audio
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as fp:
+            scipy.io.wavfile.write(fp.name, sr_rate, audio_data)
+            recog = sr.Recognizer()
+            with sr.AudioFile(fp.name) as src:
+                recorded = recog.record(src)
+                lang = "en-US" if lang_choice == "English" else "ur-PK"
+                return recog.recognize_google(recorded, language=lang).lower()
+    except Exception as e:
+        return f"[Error] Couldn't transcribe: {str(e)}"
+
+# ---- OPENAI CHAT COMPLETION ----
+def ask_openai(prompt):
+    headers = {
+        "Authorization": f"Bearer {OPENAI_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [{"role": "user", "content": prompt}]
+    }
+
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=data)
+    if response.status_code == 200:
+        return response.json()["choices"][0]["message"]["content"]
+    return "[OpenAI Error]"
+
+# ---- GAME FLOW ----
+def begin_game():
+    state["started"] = True
+    state["history"] = []
+    state["question_num"] = 1
+    state["hint_mode"] = False
+    state["current_q"] = "Does it belong to the world of living things?"
+    return (
+        "🌸 Let's start! Think of anything — a person, object, or place. I’ll guess in 20 tries!\n\n"
+        "Please reply with **yes** or **no**.\n\n"
+        f"Question 1: {state['current_q']}",
+        gr.update(visible=False),
+        gr.update(visible=True)
+    )
+
+def interpret_answer(user_answer):
+    if not state["started"]:
+        return "⛔ Start a new game first.", "", "", gr.update(visible=False)
+
+    normalized = user_answer.strip().lower()
+    if normalized not in ["yes", "no", "ہاں", "نہیں"]:
+        return "Please respond with 'yes' or 'no' (or ہاں/نہیں).", "", user_answer, gr.update(visible=state["hint_mode"])
+
+    # Record history
+    state["history"].append((state["current_q"], normalized))
+
+    if state["question_num"] >= 20:
+        state["started"] = False
+        guess = generate_final_guess()
+        return f"🎯 That's it! Here's my final guess: {guess}", "", user_answer, gr.update(visible=False)
+
+    if state["question_num"] % 5 == 0:
+        guess = generate_final_guess()
+        if "i think" in guess.lower():
+            state["current_q"] = f"{guess} Am I right?"
+            return f"🤔 {state['current_q']}", "", user_answer, gr.update(visible=state["hint_mode"])
+
+    # Next question
+    state["question_num"] += 1
+    state["current_q"] = get_next_question()
+    return f"🔎 Question {state['question_num']}: {state['current_q']}", "", user_answer, gr.update(visible=state["hint_mode"])
+
+def get_next_question():
+    history_prompt = "\n".join([f"Q: {q}\nA: {a}" for q, a in state["history"]])
+    prompt = f"""You're playing a guessing game. You can only ask yes/no questions. Based on the following history, ask the next smart question:
+
+{history_prompt}
+
+Your question:"""
+    return ask_openai(prompt).strip()
+
+def generate_final_guess():
+    history = "\n".join([f"Q: {q}\nA: {a}" for q, a in state["history"]])
+    prompt = f"""Guess the secret concept based on these Q&A. If you're not sure, say "I need more clues."
+
+{history}
+
+Your guess:"""
+    return ask_openai(prompt)
+
+def hint_response():
+    if not state["hint_mode"] or not state["started"]:
+        return "Hint mode is off or game not active."
+
+    question = state["current_q"]
+    history = "\n".join([f"{q} - {a}" for q, a in state["history"]])
+    prompt = f"""The player seems confused by this question: "{question}". Previous Q&A were:\n{history}\n\nGive a helpful, simple hint."""
+    return ask_openai(prompt)
+
+def toggle_hint_mode():
+    state["hint_mode"] = not state["hint_mode"]
+    return ("Hint Mode: ON" if state["hint_mode"] else "Hint Mode: OFF"), gr.update(visible=state["hint_mode"])
+
+# ---- UI ----
+with gr.Blocks(title="KasotiX - Original Edition") as demo:
+    gr.Markdown("<h1 style='text-align: center;'>🌼 KasotiX Game 🌼</h1>")
+    gr.Markdown("<p style='text-align: center;'>Can I guess what you're thinking in 20 tries? Think of something and let’s go!</p>")
 
     with gr.Row():
-        translated_text = gr.Textbox(label="Translated Phrase", interactive=False)
-        info = gr.Textbox(label="Instructions", interactive=False)
+        start = gr.Button("Start Game 🎲")
+        hint_toggle = gr.Button("Toggle Hint Mode 💡")
+        hint_status = gr.Textbox(value="Hint Mode: OFF", interactive=False, show_label=False)
 
     with gr.Row():
-        user_guess = gr.Textbox(label="Your English Guess")
-        submit_btn = gr.Button("✅ Submit Guess")
+        with gr.Column():
+            lang_sel = gr.Dropdown(["English", "Urdu"], label="Language", value="English")
+            mic_input = gr.Audio(sources=["microphone"], type="numpy")
+            transcribe = gr.Button("Transcribe 🎤")
+            typed_ans = gr.Textbox(label="Answer (or paste transcription here)")
+            submit = gr.Button("Submit Answer ✅")
 
-    result = gr.Textbox(label="Result", interactive=False)
+        with gr.Column():
+            game_text = gr.Textbox(label="Game Status", lines=8, interactive=False)
+            hint_box = gr.Textbox(label="Hint", visible=False)
 
-    start_btn.click(fn=start_game, inputs=[difficulty], outputs=[translated_text, info])
-    submit_btn.click(fn=check_guess, inputs=[user_guess], outputs=[result])
+    start.click(fn=begin_game, outputs=[game_text, hint_box, submit])
+    hint_toggle.click(fn=toggle_hint_mode, outputs=[hint_status, hint_box])
+    hint_toggle.click(fn=hint_response, outputs=[hint_box])
+    transcribe.click(fn=convert_audio_to_text, inputs=[mic_input, lang_sel], outputs=[typed_ans])
+    submit.click(fn=interpret_answer, inputs=[typed_ans], outputs=[game_text, typed_ans, typed_ans, hint_box])
 
 demo.launch()