Create app.py

app.py

@@ -0,0 +1,398 @@
+import gradio as gr
+import openai
+import os
+import sys
+from io import StringIO
+import traceback
+import datetime
+import pytz
+import time
+import random
+import json
+
+### --- CONSTANTS & CONFIGURATION --- ###
+MODEL_NAME = "openai/gpt-5-chat-latest" 
+MAX_HINTS = 15 
+# Set timezone to Pakistan Standard Time (PKT)
+PAKISTAN_TZ = pytz.timezone('Asia/Karachi')
+
+### --- ROBUST API CLIENT SETUP --- ###
+api_key = None
+try:
+    # Preferred method for cloud environments like Google Colab
+    from google.colab import userdata
+    api_key = userdata.get('AIML_API_KEY')
+    print("Successfully found API key in Google Colab Secrets.")
+except (ImportError, KeyError):
+    # Fallback for local development
+    api_key = os.getenv("AIML_API_KEY")
+    if api_key:
+        print("Successfully found API key in environment variables.")
+
+if not api_key:
+    print("FATAL ERROR: API Key not found. Please set the 'AIML_API_KEY' in your environment or secrets.")
+
+# Initialize the OpenAI client with the custom base URL and your API key
+client = openai.OpenAI(
+    base_url="https://api.aimlapi.com/v1",
+    api_key=api_key,
+)
+
+
+### --- HELPER & AI FUNCTIONS --- ###
+
+def make_api_call(system_prompt, user_prompt, timeout=120.0):
+    """
+    A single, robust function for all API calls.
+    """
+    if not api_key:
+        return {"success": False, "error": "API Key is not configured."}
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            timeout=timeout
+        )
+        if response.choices and response.choices[0].message and response.choices[0].message.content:
+            return {"success": True, "content": response.choices[0].message.content}
+        else:
+            return {"success": False, "error": "The AI returned an empty response."}
+    except Exception as e:
+        return {"success": False, "error": f"An API error occurred: {e}"}
+
+def generate_dynamic_curriculum(topic):
+    """
+    Asks the AI to generate a full curriculum and practice problems as a JSON object.
+    """
+    system_prompt = """
+    You are an expert Python programming instructor and curriculum designer. Your task is to generate a complete, interactive learning module based on a user-provided topic. You MUST respond with ONLY a valid JSON object and nothing else. Do not include any introductory text, markdown formatting like ```json, or any explanations outside of the JSON structure.
+
+    The JSON object must have two top-level keys: "curriculum" and "practice_problems".
+
+    1.  **curriculum**: This must be a JSON list of 2 to 3 lesson objects. Each lesson object must have:
+        - "module": A string with the name of the overall topic (e.g., "Mastering Dictionaries").
+        - "title": A string for the specific lesson title (e.g., "Lesson 1: What is a Dictionary?").
+        - "explanation": A concise, simple explanation of the concept (1-3 sentences).
+        - "check": A JSON object containing:
+            - "type": The string "mcq".
+            - "question": A string with a clear question.
+            - "options": A JSON list of 3 string options.
+            - "answer": A string that exactly matches one of the options.
+
+    2.  **practice_problems**: This must be a JSON list containing exactly ONE practice problem object. This object must have:
+        - "title": A string (e.g., "Practice: Word Frequency Counter").
+        - "problem_statement": A clear problem description.
+        - "starter_code": A string of Python code for the user to start with.
+        - "check_type": The string "variable".
+        - "check_variable": The name of the variable to check for the final answer.
+        - "expected_result": The correct final value of the check_variable (can be a number, string, list, or dictionary).
+        - "background_knowledge": A brief hint about the overall approach.
+    """
+    user_prompt = f"Generate a learning module for the Python topic: '{topic}'"
+
+    result = make_api_call(system_prompt, user_prompt)
+    
+    if result["success"]:
+        if not result["content"] or not result["content"].strip():
+            return {"success": False, "error": "The AI returned an empty response. This might be a temporary issue. Please try again."}
+        try:
+            json_string = result["content"].strip()
+            if json_string.startswith("```json"):
+                json_string = json_string[7:-3].strip()
+            
+            data = json.loads(json_string)
+            if "curriculum" in data and "practice_problems" in data:
+                return {"success": True, "data": data}
+            else:
+                return {"success": False, "error": "AI response was missing the required 'curriculum' or 'practice_problems' keys."}
+        except json.JSONDecodeError as e:
+            return {"success": False, "error": f"AI returned invalid JSON. Error: {e}\n\nRaw response received:\n{result['content']}"}
+    else:
+        return {"success": False, "error": result["error"]}
+
+
+def get_socratic_hint(problem, user_code, actual_result, error_message=None):
+    system_prompt = "You are a Socratic Python tutor. Your goal is to help a student solve a problem by asking guiding questions, never by giving the direct answer. Analyze the user's code and their incorrect result or error. Identify the logical flaw. Then, formulate a short, encouraging hint that makes them think about that specific flaw. DO NOT write any code. DO NOT give away the solution. Ask a question that leads them to the right way of thinking."
+    
+    if error_message:
+        user_prompt = f"The problem is:\n---\n{problem['problem_statement']}\n---\nThe student's code is:\n---\n{user_code}\n---\nThis code failed to run and produced this error: `{error_message}`.\nPlease provide a Socratic hint to help them fix the error."
+    else:
+        user_prompt = f"The problem is:\n---\n{problem['problem_statement']}\n---\nThe student's code is:\n---\n{user_code}\n---\nThis code produced the result `{actual_result}` instead of the expected `{problem['expected_result']}`.\nPlease provide a Socratic hint."
+
+    result = make_api_call(system_prompt, user_prompt)
+    return result["content"] if result["success"] else f"Error getting hint: {result['error']}"
+
+def execute_practice_code(user_code):
+    try:
+        local_scope = {}
+        exec(user_code, {}, local_scope)
+        return {"success": True, "scope": local_scope, "error": None}
+    except Exception:
+        error_string = traceback.format_exc()
+        return {"success": False, "scope": None, "error": error_string}
+
+def get_code_coaching(problem, user_code):
+    system_prompt = "You are an expert Python developer acting as a code coach. A student has written the following correct code. Your job is to refactor it to be more efficient, readable, or 'Pythonic' (the way a professional would write it). Then, explain your changes clearly using markdown. First show the improved code in a block, then explain the key improvements in a bulleted list."
+    user_prompt = f"The original problem was:\n---\n{problem['problem_statement']}\n---\nHere is the student's correct solution:\n---\n```python\n{user_code}\n```\n\nPlease refactor this code and explain the improvements."
+    
+    result = make_api_call(system_prompt, user_prompt)
+    return result["content"] if result["success"] else f"Error getting coaching feedback: {result['error']}"
+
+
+### --- GRADIO APP WITH DYNAMIC TUTOR --- ###
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    time_str = "Thursday, August 21, 2025 at 09:30 PM PKT"
+    
+    gr.Markdown(f"# Welcome to the AI Python Master\n*Current Location: Jhang, Punjab, Pakistan. Current Time: {time_str}*")
+
+    # --- STATE MANAGEMENT ---
+    dynamic_curriculum = gr.State([])
+    dynamic_practice_problems = gr.State([])
+    lesson_index = gr.State(0)
+    practice_attempts = gr.State(0)
+
+    # --- UI for Topic Selection ---
+    with gr.Column(visible=True) as topic_selection_ui:
+        gr.Markdown("## What Python concept do you want to master today?")
+        topic_input = gr.Textbox(label="Enter a Topic", placeholder="e.g., Python Lists, Dictionaries, For Loops, etc.")
+        generate_lesson_btn = gr.Button("Generate Lesson Plan")
+        generation_status = gr.Markdown("")
+
+    # --- UI for Dynamic Learning ---
+    with gr.Column(visible=False) as learning_ui:
+        # --- Learn Section ---
+        progress_bar = gr.Markdown("")
+        lesson_progress = gr.Markdown("")
+        explanation_box = gr.Markdown("")
+        with gr.Column() as check_ui:
+            check_question = gr.Markdown("")
+            mcq_input = gr.Radio(label="Select your answer")
+            submit_button = gr.Button("Submit Answer")
+        lesson_feedback_box = gr.Markdown("")
+        next_button = gr.Button("➡️ Continue", visible=False)
+        
+        # --- Practice Section ---
+        with gr.Column(visible=False) as practice_ui:
+            gr.Markdown("--- \n ## Practice Arena")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    practice_problem_statement = gr.Markdown("")
+                    practice_code_input = gr.Code(language="python", label="Your Code")
+                with gr.Column(scale=1):
+                    coach_feedback_box = gr.Markdown(visible=False)
+            
+            submit_practice_button = gr.Button("Run Code")
+            hint_button = gr.Button("🤔 Get a Hint", visible=False)
+            coach_button = gr.Button("🤖 Coach Me: Improve My Code", visible=False)
+            practice_feedback_box = gr.Markdown("")
+
+        success_message = gr.Markdown("🎉 **Congratulations! You have finished this module!** 🎉", visible=False)
+        start_new_topic_btn = gr.Button("Learn Another Topic", visible=False)
+
+    # --- LOGIC FOR DYNAMIC TUTOR ---
+    def generate_and_start_lesson(topic, progress=gr.Progress()):
+        progress(0, desc="Asking the AI to design your lesson... This may take a moment.")
+        
+        result = generate_dynamic_curriculum(topic)
+        
+        if not result["success"]:
+            return {
+                topic_selection_ui: gr.update(visible=True),
+                generation_status: gr.update(visible=True, value=f"❌ **Error:** {result['error']}"),
+                learning_ui: gr.update(visible=False)
+            }
+
+        new_curriculum = result["data"]["curriculum"]
+        new_practice = result["data"]["practice_problems"]
+        
+        first_lesson_ui = update_ui_for_lesson(0, new_curriculum)
+
+        return {
+            dynamic_curriculum: new_curriculum,
+            dynamic_practice_problems: new_practice,
+            lesson_index: 0,
+            practice_attempts: 0,
+            learning_ui: gr.update(visible=True),
+            topic_selection_ui: gr.update(visible=False),
+            generation_status: gr.update(visible=False),
+            **first_lesson_ui
+        }
+
+    def update_ui_for_lesson(index, current_curriculum):
+        lesson = current_curriculum[index]
+        check_data = lesson.get("check", {}) # Safer access
+        
+        total_lessons = len(current_curriculum)
+        completed_lessons = index
+        percentage = int((completed_lessons / total_lessons) * 100)
+        bar_length = 30
+        filled_length = int(bar_length * percentage / 100)
+        bar = '█' * filled_length + '░' * (bar_length - filled_length)
+        progress_text = f"**Progress:** {bar} {percentage}% ({completed_lessons}/{total_lessons} Lessons)"
+        
+        return {
+            lesson_index: index,
+            lesson_progress: f"### Module: {lesson.get('module', 'Module')} - Lesson {index + 1} / {total_lessons}",
+            explanation_box: lesson.get('explanation', ''),
+            check_ui: gr.update(visible=True),
+            check_question: f"**Question:** {check_data.get('question', '')}",
+            mcq_input: gr.update(choices=check_data.get('options', []), value=None),
+            lesson_feedback_box: "",
+            next_button: gr.update(visible=False),
+            progress_bar: progress_text
+        }
+
+    def process_answer(index, mcq_answer, current_curriculum):
+        lesson = current_curriculum[index]
+        check_data = lesson.get("check", {})
+        is_correct = str(mcq_answer).strip().lower() == str(check_data.get('answer', '')).strip().lower()
+        if is_correct:
+            return { lesson_feedback_box: "✅ **Correct!**", check_ui: gr.update(visible=False), next_button: gr.update(visible=True) }
+        else:
+            return { lesson_feedback_box: "❌ Not quite. Try again.", check_ui: gr.update(visible=True), next_button: gr.update(visible=False) }
+
+    def on_next_lesson(index, current_curriculum, current_practice):
+        new_index = index + 1
+        if new_index < len(current_curriculum):
+            return update_ui_for_lesson(new_index, current_curriculum)
+        else:
+            # End of lessons, show practice problem
+            practice_problem = current_practice[0]
+            total_lessons = len(current_curriculum)
+            bar = '█' * 30
+            progress_text = f"**Progress:** {bar} 100% ({total_lessons}/{total_lessons} Lessons)"
+            
+            return {
+                lesson_progress: "### All Lessons Complete! Now for the Practice Arena.",
+                explanation_box: "",
+                check_ui: gr.update(visible=False),
+                next_button: gr.update(visible=False),
+                practice_ui: gr.update(visible=True),
+                practice_problem_statement: practice_problem["problem_statement"],
+                practice_code_input: practice_problem["starter_code"],
+                progress_bar: progress_text,
+                lesson_index: new_index
+            }
+            
+    def process_practice_answer(user_code, current_practice):
+        problem = current_practice[0]
+        result = execute_practice_code(user_code)
+        
+        attempts = 0
+        if not result['success']:
+            return { 
+                practice_feedback_box: f"❌ **Code Error:**\n\n```\n{result['error']}\n```", 
+                hint_button: gr.update(visible=True), coach_button: gr.update(visible=False),
+                practice_attempts: attempts 
+            }
+
+        var_name = problem['check_variable']
+        expected_value = problem['expected_result']
+        actual_value = result['scope'].get(var_name, f"Variable '{var_name}' not found!")
+        
+        if str(actual_value) == str(expected_value):
+            return { 
+                practice_feedback_box: f"✅ **Success!** The variable `{var_name}` has the correct value. Great job! Now, let the AI Code Coach show you how to improve it.", 
+                hint_button: gr.update(visible=False), coach_button: gr.update(visible=True),
+                practice_attempts: 0 
+            }
+        else:
+            return { 
+                practice_feedback_box: f"�� **Incorrect Result.** Your code ran, but `{var_name}` was `{actual_value}` instead of `{expected_value}`. Try again, or ask for a hint.", 
+                hint_button: gr.update(visible=True), coach_button: gr.update(visible=False),
+                practice_attempts: attempts 
+            }
+
+    def provide_hint(user_code, current_practice, attempts):
+        new_attempts = attempts + 1
+        problem = current_practice[0]
+        
+        if new_attempts > MAX_HINTS:
+            return { 
+                practice_feedback_box: f"**Hint Limit Reached ({MAX_HINTS}/{MAX_HINTS}).**", 
+                hint_button: gr.update(visible=False),
+                practice_attempts: new_attempts
+            }
+
+        result = execute_practice_code(user_code)
+        
+        if new_attempts == 1 and result['success']:
+            hint = problem.get("background_knowledge", "No background knowledge available.")
+        else:
+            actual_value = "an error"
+            if result['success']:
+                actual_value = result['scope'].get(problem['check_variable'], "Not Found")
+            hint = get_socratic_hint(problem, user_code, actual_value, error_message=result['error'])
+        
+        return { 
+            practice_feedback_box: f"**(Hint {new_attempts}/{MAX_HINTS})** {hint}", 
+            hint_button: gr.update(visible=True),
+            practice_attempts: new_attempts
+        }
+
+    def coach_code(user_code, current_practice):
+        problem = current_practice[0]
+        coaching_text = get_code_coaching(problem, user_code)
+        return {
+            coach_feedback_box: gr.update(visible=True, value=coaching_text),
+            coach_button: gr.update(interactive=False),
+            success_message: gr.update(visible=True),
+            start_new_topic_btn: gr.update(visible=True)
+        }
+        
+    def reset_to_start():
+        return {
+            topic_selection_ui: gr.update(visible=True),
+            learning_ui: gr.update(visible=False),
+            practice_ui: gr.update(visible=False),
+            success_message: gr.update(visible=False),
+            start_new_topic_btn: gr.update(visible=False),
+            coach_feedback_box: gr.update(visible=False, value=""),
+            coach_button: gr.update(visible=False, interactive=True),
+            hint_button: gr.update(visible=False),
+            practice_feedback_box: "",
+            generation_status: ""
+        }
+
+    # --- EVENT LISTENERS ---
+    generate_lesson_btn.click(
+        fn=generate_and_start_lesson,
+        inputs=[topic_input],
+        outputs=[topic_selection_ui, generation_status, dynamic_curriculum, dynamic_practice_problems, lesson_index, practice_attempts, learning_ui, lesson_progress, explanation_box, check_ui, check_question, mcq_input, lesson_feedback_box, next_button, progress_bar]
+    )
+    submit_button.click(
+        fn=process_answer,
+        inputs=[lesson_index, mcq_input, dynamic_curriculum],
+        outputs=[lesson_feedback_box, check_ui, next_button]
+    )
+    next_button.click(
+        fn=on_next_lesson,
+        inputs=[lesson_index, dynamic_curriculum, dynamic_practice_problems],
+        outputs=[lesson_progress, explanation_box, check_ui, next_button, practice_ui, practice_problem_statement, practice_code_input, progress_bar, lesson_index]
+    )
+    submit_practice_button.click(
+        fn=process_practice_answer,
+        inputs=[practice_code_input, dynamic_practice_problems],
+        outputs=[practice_feedback_box, hint_button, coach_button, practice_attempts]
+    )
+    hint_button.click(
+        fn=provide_hint,
+        inputs=[practice_code_input, dynamic_practice_problems, practice_attempts],
+        outputs=[practice_feedback_box, hint_button, practice_attempts]
+    )
+    coach_button.click(
+        fn=coach_code,
+        inputs=[practice_code_input, dynamic_practice_problems],
+        outputs=[coach_feedback_box, coach_button, success_message, start_new_topic_btn]
+    )
+    start_new_topic_btn.click(
+        fn=reset_to_start,
+        inputs=None,
+        outputs=[topic_selection_ui, learning_ui, practice_ui, success_message, start_new_topic_btn, coach_feedback_box, coach_button, hint_button, practice_feedback_box, generation_status]
+    )
+
+if __name__ == "__main__":
+    demo.launch(debug=True)