Update app.py

app.py

@@ -1,246 +1,30 @@
-import os
-import gradio as gr
-from typing import List
-import pyttsx3
-import speech_recognition as sr
-from groq import Groq
-from mistralai import Client  # Importing the new Mistral Client
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
-# Set up API keys (in production, use proper secret management)
-os.environ["MISTRAL_API_KEY"] = "cNjUx79Hl0A2AeiAMf6yi7o7ah4APoZy"
-os.environ["GROQ_API_KEY"] = "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"
+# Load the Mistral model and tokenizer from Hugging Face Hub
+model_name = "mistralai/mistral-7b"  # Change this to the desired model name
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
 
-# Initialize clients
-mistral_client = Client(api_key=os.environ["MISTRAL_API_KEY"])  # Corrected client initialization
-groq_client = Groq(api_key=os.environ["GROQ_API_KEY"])
-
-# Initialize speech engine
-engine = pyttsx3.init()
-recognizer = sr.Recognizer()
-
-class KasotiGame:
-    def __init__(self):
-        self.reset_game()
-
-    def reset_game(self):
-        self.questions_asked = []
-        self.answers_given = []
-        self.current_question = ""
-        self.game_over = False
-        self.guess_attempted = False
-        self.current_language = "English"
-        self.audio_mode = False
-
-    def generate_question(self) -> str:
-        if len(self.questions_asked) >= 20:
-            self.game_over = True
-            return "I've reached the maximum number of questions. Game over!"
-        
-        if not self.questions_asked:
-            question = "Is it a living being?"
-        else:
-            prompt = f"""
-            We're playing a guessing game where you try to guess what I'm thinking of by asking yes/no questions.
-            Here is the history of questions and answers so far:
-            {self._format_qa_history()}
-            Based on this, generate the next yes/no question that narrows possibilities. Only output the question itself.
-            """
-            chat_response = mistral_client.chat_complete(
-                model="mistral-small-latest",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=1.5,
-                top_p=1,
-                max_tokens=0,
-                n=1
-            )
-            question = chat_response["prediction"]["content"].strip()
-            question = question.split("\n")[0]
-            if not question.endswith("?"):
-                question += "?"
-        
-        self.current_question = question
-        self.questions_asked.append(question)
-        return question
-
-    def process_answer(self, answer: str) -> str:
-        if self.game_over:
-            return "The game is already over. Please start a new game."
-
-        answer = answer.lower().strip()
-        if answer not in ["yes", "no", "y", "n"]:
-            return "Please answer with 'yes' or 'no'."
-
-        clean_answer = "yes" if answer in ["yes", "y"] else "no"
-        self.answers_given.append(clean_answer)
-
-        if len(self.questions_asked) >= 5 and len(self.questions_asked) % 3 == 0:
-            return self.make_guess()
-
-        return self.generate_question()
-
-    def make_guess(self) -> str:
-        prompt = f"""
-        We're playing a guessing game. Here’s the history:
-        {self._format_qa_history()}
-        Make your best guess. Respond like: "I think it's [your guess]." or say "I'm not sure yet."
-        """
-        chat_response = mistral_client.chat_complete(
-            model="mistral-small-latest",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=1.5,
-            top_p=1,
-            max_tokens=0,
-            n=1
-        )
-        guess = chat_response["prediction"]["content"].strip()
-        self.guess_attempted = True
-
-        if "I think it's" in guess or "I'm not sure yet" in guess:
-            return guess
-        return f"I think it's {guess}"
-
-    def get_suggestion(self) -> str:
-        if not self.current_question:
-            return "No current question to provide suggestions for."
-
-        prompt = f"""
-        A player is asked: "{self.current_question}"
-        They are unsure how to answer. Give a few hints about what typically leads to "yes" or "no" responses.
-        Be brief and helpful.
-        """
-        chat_response = groq_client.chat.completions.create(
-            model="mixtral-8x7b-32768",
-            messages=[{"role": "user", "content": prompt}]
-        )
-        return chat_response.choices[0].message.content
-
-    def _format_qa_history(self) -> str:
-        return "\n".join(f"Q: {q}\nA: {a}" for q, a in zip(self.questions_asked, self.answers_given))
-
-    def speak(self, text: str):
-        """Convert text to speech."""
-        if self.current_language == "Urdu":
-            try:
-                engine.setProperty('voice', 'ur')
-            except:
-                pass
-        else:
-            engine.setProperty('voice', 'en')
-        engine.say(text)
-        engine.runAndWait()
-
-    def listen(self) -> str:
-        """Capture and recognize speech input."""
-        with sr.Microphone() as source:
-            print("Listening...")
-            audio = recognizer.listen(source)
-            try:
-                language_code = "ur-PK" if self.current_language == "Urdu" else "en-US"
-                text = recognizer.recognize_google(audio, language=language_code)
-                return text.lower()
-            except sr.UnknownValueError:
-                return "Could not understand audio"
-            except sr.RequestError:
-                return "API unavailable"
-
-# Initialize game
-game = KasotiGame()
-
-def play_kasoti(answer: str, mode: str, language: str, use_audio: bool):
-    global game
-
-    if mode == "new":
-        game.reset_game()
-        game.audio_mode = use_audio
-        game.current_language = language
-        question = game.generate_question()
-
-        if use_audio:
-            game.speak(question)
-        return question, "", "\n".join(game.questions_asked), ""
+# Function to generate text
+def generate_text(prompt: str, max_length: int = 50):
+    # Tokenize input prompt
+    inputs = tokenizer(prompt, return_tensors="pt")
     
-    if answer.lower() in ["not sure", "unsure", "i'm not sure"]:
-        suggestion = game.get_suggestion()
-        return game.current_question, "", "\n".join(game.questions_asked), suggestion
-
-    response = game.process_answer(answer)
-
-    if game.audio_mode:
-        game.speak(response)
-
-    history = "\n".join(f"Q: {q}\nA: {a}" for q, a in zip(game.questions_asked, game.answers_given))
-
-    return response, "", history, ""
-
-def toggle_audio(audio_mode: bool):
-    game.audio_mode = audio_mode
-    return "Audio mode: ON" if audio_mode else "Audio mode: OFF"
-
-# Gradio UI
-with gr.Blocks(title="Kasoti Game") as demo:
-    gr.Markdown("# 🎮 Kasoti - The Guessing Game")
-    gr.Markdown("Think of a famous person, place, or object. I'll try to guess it by asking yes/no questions!")
-
-    with gr.Row():
-        with gr.Column():
-            language = gr.Dropdown(
-                choices=["English", "Urdu"],
-                value="English",
-                label="Select Language"
-            )
-            audio_mode = gr.Checkbox(
-                label="Enable Audio Mode",
-                value=False
-            )
-            mode = gr.Radio(
-                choices=["continue", "new"],
-                value="new",
-                label="Game Mode",
-                visible=True
-            )
-            answer = gr.Textbox(
-                label="Your Answer (yes/no)",
-                placeholder="Type 'yes', 'no', or 'not sure'"
-            )
-            submit_btn = gr.Button("Submit")
-
-            audio_status = gr.Textbox(
-                label="Audio Status",
-                interactive=False
-            )
-
-        with gr.Column():
-            output = gr.Textbox(
-                label="Game Output",
-                interactive=False
-            )
-            history = gr.Textbox(
-                label="Game History",
-                interactive=False,
-                lines=10
-            )
-            suggestion = gr.Textbox(
-                label="Suggestion (if unsure)",
-                interactive=False
-            )
-
-    # Events
-    audio_mode.change(
-        fn=toggle_audio,
-        inputs=audio_mode,
-        outputs=audio_status
-    )
-
-    submit_btn.click(
-        fn=play_kasoti,
-        inputs=[answer, mode, language, audio_mode],
-        outputs=[output, answer, history, suggestion]
+    # Generate text
+    outputs = model.generate(
+        input_ids=inputs['input_ids'],
+        max_length=max_length,  # Max tokens in output
+        num_return_sequences=1,  # Number of sequences to generate
+        temperature=0.7,  # Adjust for randomness (higher = more random)
+        top_p=0.9,  # Use top-p sampling for diversity
+        top_k=50  # Top-k sampling for diversity
     )
-
-    demo.load(
-        fn=lambda: ("", "", "", ""),
-        outputs=[output, answer, history, suggestion]
-    )
-
-if __name__ == "__main__":
-    demo.launch()
+    
+    # Decode the generated text and return it
+    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return generated_text
+
+# Example usage
+prompt = "The future of artificial intelligence is"
+generated_output = generate_text(prompt)
+print("Generated Text:", generated_output)