Update app.py

app.py

@@ -469,446 +469,6 @@ def check_health():
     
     return problems
 
-if __name__ == "__main__":
-    logging.info("Starting Vers3Dynamics Tutor application")
-    
-    health_issues = check_health()
-    if health_issues:
-        for issue in health_issues:
-            logging.critical(f"Health check failed: {issue}")
-        logging.critical("Application may not function properly due to the above issues")
-    
-    try:
-        demo = create_interface()
-        logging.info("Gradio interface created successfully")
-        
-        try:
-            logging.info("Launching Gradio server")
-            demo.queue()
-            demo.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                debug=True
-            )
-        except Exception as e:
-            logging.critical(f"Failed to launch Gradio server: {str(e)}")
-            logging.critical(traceback.format_exc())
-    except Exception as e:
-        logging.critical(f"Failed to create Gradio interface: {str(e)}")
-        logging.critical(traceback.format_exc())    client = Groq(api_key=api_key)
-    logging.debug("Groq client initialized successfully")
-    
-    # Test the client with a simple API call
-    try:
-        models = client.models.list()
-        logging.debug(f"API connection test successful. Available models: {[m.id for m in models.data][:3]}...")
-    except Exception as e:
-        logging.warning(f"API connection test failed: {e}")
-except Exception as e:
-    logging.critical(f"Failed to initialize Groq client: {str(e)}")
-    logging.critical(traceback.format_exc())
-    raise EnvironmentError(f"Error initializing Groq API client: {str(e)}")
-
-def transcribe_audio(audio):
-    """Transcribe audio file to text using Groq's API."""
-    try:
-        if audio is None:
-            logging.debug("No audio input provided")
-            return ""
-        
-        logging.debug(f"Audio input received: {type(audio)} - {audio}")
-        
-        audio_path = audio if isinstance(audio, str) else audio
-        logging.debug(f"Audio path: {audio_path}")
-        logging.debug(f"File exists: {os.path.exists(audio_path) if audio_path else False}")
-        
-        if audio_path and os.path.exists(audio_path):
-            with open(audio_path, "rb") as audio_file:
-                audio_data = audio_file.read()
-                
-            logging.debug(f"Audio file opened, size: {len(audio_data)} bytes")
-            
-            try:
-                logging.debug("Sending audio to Groq API for transcription")
-                transcription = client.audio.transcriptions.create(
-                    file=("audio.wav", audio_data),
-                    model="distil-whisper-large-v3-en",
-                )
-                
-                logging.debug(f"Transcription response received: {transcription}")
-                
-                if hasattr(transcription, 'text'):
-                    result = transcription.text
-                    logging.debug(f"Transcription text: {result}")
-                    return result
-                else:
-                    result = transcription.get('text', "Transcription succeeded but returned no text")
-                    logging.debug(f"Transcription text (alt format): {result}")
-                    return result
-            except Exception as e:
-                logging.error(f"Audio transcription API error: {str(e)}")
-                return f"Audio transcription failed: {str(e)}"
-        else:
-            logging.warning(f"Audio file not found at path: {audio_path}")
-            return "Audio file not found. Please try recording again."
-    except Exception as e:
-        logging.error(f"Error in transcription: {str(e)}")
-        return f"Error in transcription: {str(e)}"
-
-def generate_tutor_output(subject: str, difficulty: str, student_input: str) -> Dict[str, str]:
-    """Generate educational content based on student input."""
-    try:
-        logging.debug(f"Generating tutor output for subject: {subject}, difficulty: {difficulty}")
-        logging.debug(f"Student input: {student_input}")
-        
-        # Define enhanced topics for all subjects
-        topics = {
-            "math": {
-                "quadratic equation": "solving quadratic equations, including methods like factoring, using the quadratic formula, and completing the square",
-                "pythagorean theorem": "the Pythagorean theorem, its proof, and applications in geometry and trigonometry",
-                "calculus": "fundamental concepts of calculus, including limits, derivatives, and integrals",
-                "linear algebra": "basics of linear algebra, including vectors, matrices, and linear transformations",
-                "statistics": "key concepts in statistics, such as probability distributions, hypothesis testing, and regression analysis"
-            },
-            "science": {
-                "photosynthesis": "the process of photosynthesis in plants, including light-dependent and light-independent reactions",
-                "newton's laws": "Newton's laws of motion and their applications in classical mechanics",
-                "periodic table": "the structure and organization of the periodic table of elements",
-                "dna replication": "the process of DNA replication and its importance in cell division",
-                "climate change": "the causes and effects of climate change, including global warming and its impact on ecosystems"
-            },
-        }
-        
-        subject_lower = subject.lower() if subject else "general"
-        enhanced_topic = None
-        for subj, subject_topics in topics.items():
-            for topic, description in subject_topics.items():
-                if topic.lower() in student_input.lower():
-                    enhanced_topic = description
-                    logging.debug(f"Enhanced topic detected: {topic}")
-                    break
-            if enhanced_topic:
-                break
-        
-        # Strengthened prompt with strict quiz formatting
-        if enhanced_topic:
-            logging.debug(f"Using enhanced topic: {enhanced_topic}")
-            prompt = f"""
-            You are an expert tutor specializing in {enhanced_topic} at the {difficulty} level. The student has asked: "{student_input}"
-            Generate a detailed response as a valid JSON object with exactly these keys and content:
-            - "lesson": A comprehensive lesson (3-4 paragraphs, at least 200 words) based on national educational standards, including historical context.
-            - "example": A detailed step-by-step example problem with a full solution, formatted as: "Example Problem: [question]\nStep 1: [step]\nStep 2: [step]\nAnswer: [solution]".
-            - "real_world_problem": A challenging real-world application of this concept (at least 100 words).
-            - "quiz": A single string containing exactly 3 multiple-choice questions, each formatted as "1. [Question]\n   a) [option]\n   b) [option]\n   c) [option]\n   Correct answer: [letter]", separated by newlines.
-            Ensure all sections are fully populated with relevant content. Return only the JSON object, enclosed in ```json``` markers, with no additional text outside the markers.
-            """
-        else:
-            logging.debug(f"Using general subject: {subject_lower}")
-            prompt = f"""
-            You are an expert tutor in {subject_lower} at the {difficulty} level. The student has asked: "{student_input}"
-            Generate a detailed response as a valid JSON object with exactly these keys and content:
-            - "lesson": A descriptive, engaging lesson (3-4 paragraphs, at least 200 words) on the topic.
-            - "example": An example problem with a full solution, formatted as: "Example Problem: [question]\nStep 1: [step]\nStep 2: [step]\nAnswer: [solution]".
-            - "real_world_problem": A real-world problem solvable using the lesson concepts (at least 100 words).
-            - "quiz": A single string containing exactly 3 multiple-choice questions, each formatted as "1. [Question]\n   a) [option]\n   b) [option]\n   c) [option]\n   Correct answer: [letter]", separated by newlines.
-            Ensure all sections are fully populated with relevant content. Return only the JSON object, enclosed in ```json``` markers, with no additional text outside the markers.
-            """
-        
-        # Model selection with fallback
-        try:
-            models = client.models.list()
-            available_models = [m.id for m in models.data]
-            logging.debug(f"Available models: {available_models}")
-            target_model = "llama-3.3-70b-versatile" if "llama-3.3-70b-versatile" in available_models else available_models[0]
-        except Exception:
-            logging.warning("Could not fetch model list, using default model")
-            target_model = "llama-3.3-70b-versatile"
-        
-        logging.debug(f"Sending prompt to model: {target_model}")
-        
-        completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "system",
-                    "content": f"You are the world's best AI tutor, renowned for your ability to explain complex concepts clearly and engagingly. Your expertise in {subject_lower} is unparalleled, and you tailor your teaching to {difficulty} level students. Always return a complete response with all requested sections as a valid JSON object enclosed in ```json``` markers.",
-                },
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
-            model=target_model,
-            max_tokens=4000,
-        )
-        
-        response_content = completion.choices[0].message.content
-        logging.debug(f"Raw API response: {response_content}")
-        
-        # Extract JSON from response
-        json_match = re.search(r'```json\s*([\s\S]*?)\s*```', response_content)
-        if json_match:
-            json_str = json_match.group(1)
-            try:
-                result = json.loads(json_str)
-                logging.debug("Successfully parsed JSON from response")
-            except json.JSONDecodeError as e:
-                logging.warning(f"JSON parsing failed: {e}")
-                result = None
-        else:
-            logging.warning("No JSON markers found in response")
-            result = None
-        
-        # Improved fallback parsing
-        if not result:
-            logging.debug("Falling back to text parsing")
-            sections = {
-                "lesson": "",
-                "example": "",
-                "real_world_problem": "",
-                "quiz": ""
-            }
-            lines = response_content.split('\n')
-            current_section = None
-            for line in lines:
-                line = line.strip()
-                if not line or line.startswith('```'):
-                    continue
-                if any(kw in line.lower() for kw in ["lesson", "1.", "overview", "introduction"]):
-                    current_section = "lesson"
-                    sections[current_section] += line.replace("Lesson:", "").replace("1.", "").strip() + "\n"
-                elif any(kw in line.lower() for kw in ["example", "2.", "problem", "solution"]):
-                    current_section = "example"
-                    sections[current_section] += line.replace("Example:", "").replace("2.", "").strip() + "\n"
-                elif any(kw in line.lower() for kw in ["real-world", "application", "3.", "practical"]):
-                    current_section = "real_world_problem"
-                    sections[current_section] += line.replace("Real-World Application:", "").replace("Real-World Problem:", "").replace("3.", "").strip() + "\n"
-                elif any(kw in line.lower() for kw in ["quiz", "4.", "question", "test"]):
-                    current_section = "quiz"
-                    sections[current_section] += line.replace("Quiz:", "").replace("4.", "").strip() + "\n"
-                elif current_section:
-                    sections[current_section] += line + "\n"
-            
-            logging.debug(f"Parsed sections: {sections}")
-            result = sections
-        
-        # Ensure all keys are present and non-empty
-        for key in ["lesson", "example", "real_world_problem", "quiz"]:
-            if key not in result or not result[key].strip():
-                result[key] = f"No {key.replace('_', ' ')} provided - generation incomplete"
-        
-        return result
-    
-    except Exception as e:
-        logging.error(f"Error in generate_tutor_output: {str(e)}")
-        logging.error(traceback.format_exc())
-        return {
-            "lesson": f"Error: {str(e)}",
-            "example": "",
-            "real_world_problem": "",
-            "quiz": ""
-        }
-
-def process_output(output: Dict[str, Any]) -> Tuple[str, str, str, str]:
-    """Process the output from generate_tutor_output into HTML format."""
-    try:
-        logging.debug(f"Processing output: {str(output)}")
-        
-        lesson = markdown2.markdown(output.get("lesson", "No lesson available"))
-        example = markdown2.markdown(output.get("example", "No example available"))
-        real_world = markdown2.markdown(output.get("real_world_problem", "No real-world application available"))
-        quiz = markdown2.markdown(output.get("quiz", "No quiz available"))
-        
-        logging.debug("Output processed successfully")
-        return lesson, example, real_world, quiz
-    except Exception as e:
-        logging.error(f"Error processing output: {str(e)}")
-        logging.error(traceback.format_exc())
-        return f"Error processing output: {str(e)}", "", "", ""
-
-def create_interface() -> gr.Blocks:
-    """Create the Gradio interface."""
-    logging.debug("Creating Gradio interface")
-    
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🎓 Vers3Dynamics Tutor: Your Personal Learning Companion")
-        
-        state = gr.State({"is_submitting": False})
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                subject = gr.Dropdown(
-                    ["Art History", "Computer Science", "Literature", "Math", "Music", "Science", "Social Science"],
-                    label="Subject",
-                    info="Choose the subject of your lesson",
-                    value="Math"
-                )
-                difficulty = gr.Radio(
-                    ["Primary", "Secondary", "Higher Education"],
-                    label="Difficulty Level",
-                    info="Select your proficiency level",
-                    value="Secondary"
-                )
-                student_input = gr.Textbox(
-                    placeholder="Type your topic or question here...",
-                    label="Type Your Question",
-                    info="Enter the topic you want to explore"
-                )
-                audio_input = gr.Audio(
-                    type="filepath",
-                    label="Speak Your Question",
-                    sources=["microphone"],
-                    format="wav"
-                )
-                
-                with gr.Row():
-                    submit_button = gr.Button("📚 Teach Me", variant="primary")
-                    clear_button = gr.Button("🧹 Clear", variant="secondary")
-                    
-                status_indicator = gr.Textbox(
-                    label="Status",
-                    value="Ready",
-                    interactive=False
-                )
-
-            with gr.Column(scale=3):
-                transcription_output = gr.Textbox(label="Transcribed Audio (if provided)")
-                lesson_output = gr.HTML(label="Lesson")
-                example_output = gr.HTML(label="Example")
-                real_world_output = gr.HTML(label="Real-World Application")
-                quiz_output = gr.HTML(label="Quiz")
-
-        gr.Markdown("""
-        ### How to Use
-        1. Select a subject from the dropdown.
-        2. Choose your difficulty level.
-        3. Enter the topic or question you'd like to explore, or use the microphone to speak your question.
-        4. Click 'Teach Me' to receive a personalized lesson, example, real-world application, and quiz.
-        5. Review the AI-generated content to enhance your learning.
-        6. Use the 'Clear' button to reset all fields and start a new query.
-        7. Feel free to ask follow-up questions or explore new topics!
-        Remember: This is an AI-powered educational tool. Always verify important information with authoritative sources.
-        ### How to Record Your Voice
-        1. Look for the microphone icon in the "Or speak your question" section.
-        2. Click on the microphone icon to start recording.
-        3. Speak clearly and at a normal pace into your device's microphone.
-        4. Click the stop button (square icon) when you're done speaking.
-        5. You can play back your recording using the play button to check if it's clear.
-        6. If you're satisfied with the recording, click 'Teach Me' to process your spoken question.
-        7. If you're not happy with the recording, you can click the microphone icon again to start over.
-        Note: Make sure your browser has permission to access your microphone. If you encounter any issues, try using a different browser or check your device's audio settings.
-        """)
-
-        def process_input(subject, difficulty, text_input, audio_input, state):
-            """Process input from text or audio."""
-            try:
-                logging.info(f"Received inputs - subject: {subject}, difficulty: {difficulty}")
-                logging.info(f"Text input: '{text_input}', Audio input: {audio_input}")
-                
-                subject = subject or "Math"
-                difficulty = difficulty or "Secondary"
-                
-                if not text_input.strip() and not audio_input:
-                    return (
-                        {"is_submitting": False},
-                        "Ready",
-                        "No input provided",
-                        "Please provide a question to begin",
-                        "",
-                        "",
-                        ""
-                    )
-                
-                if text_input.strip():
-                    student_input = text_input.strip()
-                    transcribed_text = "Using text input"
-                elif audio_input:
-                    transcribed_text = transcribe_audio(audio_input)
-                    student_input = transcribed_text
-                    if "error" in transcribed_text.lower():
-                        return (
-                            {"is_submitting": False},
-                            "Ready",
-                            transcribed_text,
-                            "Transcription error. Please try typing your question.",
-                            "",
-                            "",
-                            ""
-                        )
-                else:
-                    return (
-                        {"is_submitting": False},
-                        "Ready",
-                        "No valid input",
-                        "Please provide a question",
-                        "",
-                        "",
-                        ""
-                    )
-                
-                tutor_output = generate_tutor_output(subject, difficulty, student_input)
-                lesson, example, real_world, quiz = process_output(tutor_output)
-                
-                return (
-                    {"is_submitting": False},
-                    "Ready",
-                    transcribed_text,
-                    lesson,
-                    example,
-                    real_world,
-                    quiz
-                )
-            
-            except Exception as e:
-                logging.error(f"Error in process_input: {str(e)}")
-                logging.error(traceback.format_exc())
-                return (
-                    {"is_submitting": False},
-                    "Error",
-                    f"Error: {str(e)}",
-                    f"Error processing request: {str(e)}",
-                    "",
-                    "",
-                    ""
-                )
-
-        def clear_outputs():
-            """Clear all inputs and outputs."""
-            logging.debug("Clearing all outputs")
-            return {"is_submitting": False}, "Ready", "", "", "", "", "", ""
-
-        submit_button.click(
-            fn=process_input,
-            inputs=[subject, difficulty, student_input, audio_input, state],
-            outputs=[state, status_indicator, transcription_output, lesson_output, example_output, real_world_output, quiz_output]
-        )
-
-        clear_button.click(
-            fn=clear_outputs,
-            inputs=[],
-            outputs=[state, status_indicator, student_input, transcription_output, lesson_output, example_output, real_world_output, quiz_output]
-        )
-
-    return demo
-
-def check_health():
-    """Perform a health check of required components."""
-    problems = []
-    
-    if not os.getenv("GROQ_API_KEY"):
-        problems.append("GROQ_API_KEY environment variable is not set")
-    
-    try:
-        import markdown2
-    except ImportError:
-        problems.append("markdown2 package is not installed")
-    
-    try:
-        client = Groq(api_key=os.getenv("GROQ_API_KEY") or "dummy_key_for_test")
-    except Exception as e:
-        problems.append(f"Groq client initialization failed: {str(e)}")
-    
-    return problems
-
 if __name__ == "__main__":
     logging.info("Starting Vers3Dynamics Tutor application")