Update app.py

app.py

@@ -1,198 +1,248 @@
 import os
+import re
 import gradio as gr
+from typing import Tuple, Dict, List
 from deep_translator import GoogleTranslator
-import google.generativeai as genai
 from groq import Groq
+import google.generativeai as genai
 from dotenv import load_dotenv
 
-# Load environment variables
-load_dotenv()
-
-# Configure API keys
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-
-# Configure Gemini
-if GEMINI_API_KEY:
-    genai.configure(api_key=GEMINI_API_KEY)
-
-# Configure Groq
-groq_client = None
-if GROQ_API_KEY:
-    groq_client = Groq(api_key=GROQ_API_KEY)
-
-# Supported languages
-LANGUAGES = {
-    "English": "en",
-    "Spanish": "es",
-    "French": "fr",
-    "German": "de",
-    "Chinese": "zh",
-    "Japanese": "ja",
-    "Korean": "ko",
-    "Hindi": "hi",
-    "Arabic": "ar",
-    "Russian": "ru"
-}
-
-def translate_text(text, source_lang, target_lang):
-    """Translate text between languages."""
-    if source_lang == target_lang:
-        return text
-        
-    try:
-        translator = GoogleTranslator(source=source_lang, target=target_lang)
-        return translator.translate(text)
-    except Exception as e:
-        print(f"Translation error: {str(e)}")
-        return text
-
-def get_gemini_response(question):
-    """Get response from Gemini model."""
-    try:
-        model = genai.GenerativeModel(
-            model_name="gemini-1.5-flash-002",
-            generation_config={
-                "temperature": 0.7,
-                "max_output_tokens": 4096
-            }
-        )
-        response = model.generate_content(question)
-        return response.text
-    except Exception as e:
-        print(f"Gemini error: {str(e)}")
-        return None
-
-def get_groq_response(question):
-    """Get response from Groq model."""
-    try:
-        response = groq_client.chat.completions.create(
-            model="llama3-70b-8192",
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": question}
-            ],
-            temperature=0.7,
-            max_tokens=4096
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        print(f"Groq error: {str(e)}")
-        return None
-
-def process_question(question, language, question_type):
-    """Process the question and return responses."""
+# Load environment variables - Adapted for Hugging Face
+load_dotenv()  # Ensure to call the function to load the environment variables
+
+# Multiple Groq API Keys
+GROQ_API_KEYS = [
+    os.getenv("GORQ_API_KEY_1"),
+    os.getenv("GORQ_API_KEY_2"),
+    os.getenv("GORQ_API_KEY_3"),
+    os.getenv("GORQ_API_KEY_4"),
+    os.getenv("GORQ_API_KEY_5")
+]
+
+# Multiple Gemini API Keys
+GEMINI_API_KEYS = [
+    os.getenv("GEMINI_API_KEY_1"),
+    os.getenv("GEMINI_API_KEY_2"),
+    os.getenv("GEMINI_API_KEY_3"),
+    os.getenv("GEMINI_API_KEY_4"),
+    os.getenv("GEMINI_API_KEY_5")
+]
+
+class TextCleaner:
+    """Handles cleaning and structuring of input text."""
     
-    # Check if we have any API keys configured
-    if not GEMINI_API_KEY and not GROQ_API_KEY:
-        error_msg = "No API keys configured. Please add GEMINI_API_KEY or GROQ_API_KEY to your environment variables."
-        return error_msg, error_msg, error_msg
+    @staticmethod
+    def clean_markdown(text: str) -> str:
+        """Remove unnecessary markdown and formatting symbols."""
+        # Remove excessive markdown symbols
+        text = re.sub(r'#{3,}', '##', text)
+        text = re.sub(r'\*{3,}', '**', text)
+        text = re.sub(r'_{3,}', '__', text)
+        text = re.sub(r'~{3,}', '~~', text)
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        text = re.sub(r' {2,}', ' ', text)
+        text = re.sub(r'`{3,}', '```', text)
+        return text.strip()
+
+class LanguageManager:
+    """Manages supported languages and their configurations."""
     
-    try:
-        # Get language codes
-        source_lang = LANGUAGES.get(language, "en")
-        
-        # Translate question to English if needed
-        english_question = translate_text(question, source_lang, "en") if language != "English" else question
-        
-        # Get model response
-        answer = None
+    SUPPORTED_LANGUAGES: Dict[str, str] = {
+        # Languages mapping...
+    }
+    
+    @classmethod
+    def get_language_code(cls, language_name: str) -> str:
+        return cls.SUPPORTED_LANGUAGES.get(language_name.lower(), "en")
+    
+    @classmethod
+    def get_language_name(cls, language_code: str) -> str:
+        for name, code in cls.SUPPORTED_LANGUAGES.items():
+            if code == language_code:
+                return name.replace('_', ' ').title()
+        return "English"
+
+class ModelManager:
+    """Manages different language models and their responses."""
+    
+    def __init__(self):
+        self.model_configs = {
+            "math": "llama3-70b-8192",
+            "job": "llama-3.2-90b-text-preview",
+            "general": "gemini-1.5-flash-002"
+        }
         
-        # Try Gemini first
-        if GEMINI_API_KEY:
-            answer = get_gemini_response(english_question)
+        # Initialize API clients
+        self.groq_client = self._initialize_groq_client()
+        self.gemini_client = self._initialize_gemini_client()
+
+    def _initialize_groq_client(self):
+        for key in GROQ_API_KEYS:
+            if key:  # Check if the key is valid
+                return Groq(api_key=key)
+        raise ValueError("No valid Groq API keys found.")
+
+    def _initialize_gemini_client(self):
+        for key in GEMINI_API_KEYS:
+            if key:  # Check if the key is valid
+                genai.configure(api_key=key)
+                return
+        raise ValueError("No valid Gemini API keys found.")
+
+    def get_model_response(self, question: str, question_type: str) -> str:
+        """Get response from appropriate model with preprocessing."""
+        model_name = self.model_configs.get(question_type, self.model_configs["general"])
         
-        # If Gemini fails or isn't available, try Groq
-        if answer is None and GROQ_API_KEY:
-            answer = get_groq_response(english_question)
+        try:
+            if "gemini" in model_name and GEMINI_API_KEYS[0]:  # Use the first Gemini key
+                return self._get_gemini_response(question)
+            elif GROQ_API_KEYS[0]:  # Use the first Groq key
+                return self._get_groq_response(question, model_name)
+            else:
+                return "API keys not configured. Please check your environment variables."
+        except Exception as e:
+            print(f"Model error: {str(e)}")
+            return "I apologize, but I'm unable to process your request at the moment. Please try again later."
+
+    def _get_groq_response(self, question: str, model_name: str) -> str:
+        """Get response from Groq model."""
+        try:
+            response = self.groq_client.chat.completions.create(
+                model=model_name,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant. For calculations, show step-by-step solutions."},
+                    {"role": "user", "content": question}
+                ],
+                temperature=0.7,
+                max_tokens=4096  # Reduced for better performance
+            )
+            return TextCleaner.clean_markdown(response.choices[0].message.content)
+        except Exception as e:
+            raise Exception(f"Groq API error: {str(e)}")
+
+    def _get_gemini_response(self, question: str) -> str:
+        """Get response from Gemini model."""
+        try:
+            model = genai.GenerativeModel(
+                model_name="gemini-1.5-flash-002",
+                generation_config={
+                    "temperature": 0.7,
+                    "max_output_tokens": 4096  # Reduced for better performance
+                }
+            )
+            response = model.generate_content(question)
+            return TextCleaner.clean_markdown(response.text)
+        except Exception as e:
+            raise Exception(f"Gemini API error: {str(e)}")
+
+class TranslationManager:
+    """Manages translation between different languages."""
+    
+    def __init__(self):
+        self._supported_languages = set(LanguageManager.SUPPORTED_LANGUAGES.values())
+        self._translation_cache: Dict[str, str] = {}
+
+    def translate_text(self, text: str, source_lang: str, target_lang: str) -> str:
+        """Translate text between languages with caching and error handling."""
+        if source_lang == target_lang:
+            return text
             
-        if answer is None:
-            return "Error getting response", "Error getting response", "Error getting response"
+        cache_key = f"{source_lang}:{target_lang}:{text}"
+        if cache_key in self._translation_cache:
+            return self._translation_cache[cache_key]
             
-        # Translate answer back to original language if needed
-        translated_answer = translate_text(answer, "en", source_lang) if language != "English" else answer
+        try:
+            translator = GoogleTranslator(source=source_lang, target=target_lang)
+            translated_text = translator.translate(text)
+            self._translation_cache[cache_key] = translated_text
+            return translated_text
+        except Exception as e:
+            print(f"Translation error: {str(e)}")
+            return text
+
+class QuestifyAI:
+    """Main application class for multilingual question answering."""
+
+    def __init__(self):
+        self.translation_manager = TranslationManager()
+        self.model_manager = ModelManager()
+
+    def process_question(
+        self, 
+        question: str, 
+        input_language: str, 
+        question_type: str
+    ) -> Tuple[str, str, str]:
+        """Process a question through translation and model response pipeline."""
+        # Clean input
+        question = re.sub(r"[#/*\\]", "", question).strip()
         
-        return english_question, answer, translated_answer
+        # Get language code
+        language_code = LanguageManager.get_language_code(input_language)
         
-    except Exception as e:
-        error_msg = f"Error: {str(e)}"
-        return error_msg, error_msg, error_msg
+        # Translate to English if needed
+        english_question = (self.translation_manager.translate_text(question, language_code, "en") 
+                          if language_code != "en" else question)
 
-def create_ui():
-    """Create the Gradio interface."""
-    
-    # Determine which APIs are available
-    available_apis = []
-    if GEMINI_API_KEY:
-        available_apis.append("Gemini")
-    if GROQ_API_KEY:
-        available_apis.append("Groq")
-    
-    api_status = f"Active APIs: {', '.join(available_apis)}" if available_apis else "No APIs configured"
-    
-    with gr.Blocks(title="AI Question Answering") as app:
-        gr.Markdown("# AI Question Answering System")
-        gr.Markdown(f"**{api_status}**")
-        
-        with gr.Row():
-            with gr.Column():
-                # Input components
+        # Get model response
+        english_answer = self.model_manager.get_model_response(english_question, question_type)
+
+        # Translate answer back if needed
+        translated_answer = (self.translation_manager.translate_text(english_answer, "en", language_code) 
+                           if language_code != "en" else english_answer)
+
+        return english_question, english_answer, translated_answer
+
+    def create_ui(self):
+        """Create Gradio interface for QuestifyAI."""
+        with gr.Blocks(title="Questify AI") as app:
+            gr.Markdown("# Questify AI - Multilingual Question Answering")
+            
+            with gr.Row():
                 question_input = gr.Textbox(
                     label="Your Question",
                     placeholder="Type your question here...",
                     lines=5
                 )
                 
-                with gr.Row():
+                with gr.Column():
                     language_input = gr.Dropdown(
-                        label="Language",
-                        choices=list(LANGUAGES.keys()),
+                        label="Select Language",
+                        choices=sorted([name.replace('_', ' ').title() 
+                                     for name in LanguageManager.SUPPORTED_LANGUAGES.keys()]),
                         value="English"
                     )
-                    
                     question_type = gr.Dropdown(
                         label="Question Type",
                         choices=["general", "math", "job"],
                         value="general"
                     )
-                
-                submit_btn = gr.Button("Submit", variant="primary")
-                clear_btn = gr.Button("Clear")
-        
-        with gr.Row():
-            # Output components
-            english_question = gr.Textbox(
-                label="English Question",
-                lines=3,
-                interactive=False
-            )
-            english_answer = gr.Textbox(
-                label="English Answer",
-                lines=5,
-                interactive=False
-            )
-            translated_answer = gr.Textbox(
-                label="Translated Answer",
-                lines=5,
-                interactive=False
+
+            submit_btn = gr.Button("Submit", variant="primary")
+            clear_btn = gr.Button("Clear")
+
+            with gr.Row():
+                english_question = gr.Textbox(label="Structured English Question", lines=3)
+                english_answer = gr.Textbox(label="Answer in English", lines=5)
+                translated_answer = gr.Textbox(label="Translated Answer", lines=5)
+
+            def handle_submit(question, language, q_type):
+                try:
+                    return self.process_question(question, language, q_type)
+                except Exception as e:
+                    return str(e), "", ""
+
+            submit_btn.click(
+                handle_submit, 
+                inputs=[question_input, language_input, question_type], 
+                outputs=[english_question, english_answer, translated_answer]
             )
-        
-        # Button actions
-        submit_btn.click(
-            process_question,
-            inputs=[question_input, language_input, question_type],
-            outputs=[english_question, english_answer, translated_answer]
-        )
-        
-        clear_btn.click(
-            lambda: ("", "", ""),
-            outputs=[english_question, english_answer, translated_answer]
-        )
-    
-    return app
 
-# Create and launch the app
-app = create_ui()
+            clear_btn.click(lambda: ("", "", ""), outputs=[question_input, english_question, english_answer, translated_answer])
+
+        return app
 
 if __name__ == "__main__":
-    app.launch()
+    app = QuestifyAI()
+    ui = app.create_ui()
+    ui.launch()