Update app.py

app.py

@@ -0,0 +1,458 @@
+import os
+import random
+import json
+import gradio as gr
+import google.generativeai as genai
+
+# Configure Gemini API - For Hugging Face deployment
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Challenge database with different difficulty levels
+challenges = {
+    "easy": [
+        {
+            "id": "e1",
+            "title": "Sum of Two Numbers",
+            "description": "Write a function that takes two numbers as input and returns their sum.",
+            "example_input": "5, 3",
+            "example_output": "8",
+            "test_cases": [
+                {"input": "5, 3", "output": "8"},
+                {"input": "10, -5", "output": "5"},
+                {"input": "0, 0", "output": "0"}
+            ]
+        },
+        {
+            "id": "e2",
+            "title": "Even or Odd",
+            "description": "Write a function that determines if a number is even or odd.",
+            "example_input": "4",
+            "example_output": "Even",
+            "test_cases": [
+                {"input": "4", "output": "Even"},
+                {"input": "7", "output": "Odd"},
+                {"input": "0", "output": "Even"}
+            ]
+        },
+        {
+            "id": "e3",
+            "title": "String Reversal",
+            "description": "Write a function that reverses a string.",
+            "example_input": "hello",
+            "example_output": "olleh",
+            "test_cases": [
+                {"input": "hello", "output": "olleh"},
+                {"input": "python", "output": "nohtyp"},
+                {"input": "a", "output": "a"}
+            ]
+        }
+    ],
+    "medium": [
+        {
+            "id": "m1",
+            "title": "Palindrome Check",
+            "description": "Write a function that checks if a string is a palindrome (reads the same backward as forward).",
+            "example_input": "racecar",
+            "example_output": "True",
+            "test_cases": [
+                {"input": "racecar", "output": "True"},
+                {"input": "hello", "output": "False"},
+                {"input": "A man a plan a canal Panama", "output": "True"}
+            ]
+        },
+        {
+            "id": "m2",
+            "title": "List Comprehension",
+            "description": "Write a function that returns a list of all even numbers from 1 to n using list comprehension.",
+            "example_input": "10",
+            "example_output": "[2, 4, 6, 8, 10]",
+            "test_cases": [
+                {"input": "10", "output": "[2, 4, 6, 8, 10]"},
+                {"input": "5", "output": "[2, 4]"},
+                {"input": "1", "output": "[]"}
+            ]
+        },
+        {
+            "id": "m3",
+            "title": "Fibonacci Sequence",
+            "description": "Write a function that returns the nth number in the Fibonacci sequence.",
+            "example_input": "6",
+            "example_output": "8",
+            "test_cases": [
+                {"input": "6", "output": "8"},
+                {"input": "1", "output": "1"},
+                {"input": "10", "output": "55"}
+            ]
+        }
+    ],
+    "hard": [
+        {
+            "id": "h1",
+            "title": "Anagram Check",
+            "description": "Write a function that determines if two strings are anagrams of each other.",
+            "example_input": "listen, silent",
+            "example_output": "True",
+            "test_cases": [
+                {"input": "listen, silent", "output": "True"},
+                {"input": "hello, world", "output": "False"},
+                {"input": "Astronomer, Moon starer", "output": "True"}
+            ]
+        },
+        {
+            "id": "h2",
+            "title": "Prime Number Generator",
+            "description": "Write a function that generates all prime numbers up to n using the Sieve of Eratosthenes algorithm.",
+            "example_input": "30",
+            "example_output": "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]",
+            "test_cases": [
+                {"input": "30", "output": "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]"},
+                {"input": "10", "output": "[2, 3, 5, 7]"},
+                {"input": "2", "output": "[2]"}
+            ]
+        },
+        {
+            "id": "h3",
+            "title": "Recursive Binary Search",
+            "description": "Write a recursive function that performs binary search on a sorted list.",
+            "example_input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 7",
+            "example_output": "6",
+            "test_cases": [
+                {"input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 7", "output": "6"},
+                {"input": "[1, 2, 3, 4, 5], 1", "output": "0"},
+                {"input": "[1, 3, 5, 7, 9], 4", "output": "-1"}
+            ]
+        }
+    ]
+}
+
+# User session data
+user_data = {
+    "current_challenge": None,
+    "difficulty_level": "easy",
+    "correct_answers": 0,
+    "total_attempts": 0,
+    "solution_history": []  # Store previous solutions for LLM analysis
+}
+
+def get_challenge():
+    """Get a random challenge based on the current difficulty level"""
+    level = user_data["difficulty_level"]
+    available_challenges = challenges[level]
+    challenge = random.choice(available_challenges)
+    user_data["current_challenge"] = challenge
+    return challenge
+
+def evaluate_code_with_gemini(user_code, challenge):
+    """Evaluate the user's code using Gemini API"""
+    try:
+        # Check if API key is available
+        if not GEMINI_API_KEY:
+            return {
+                "test_results": [],
+                "overall_assessment": "API Key Missing",
+                "feedback": "The Gemini API key is not configured. Please check the Hugging Face Space settings.",
+                "is_correct": False,
+                "code_quality_score": 5,
+                "algorithm_efficiency_score": 5
+            }
+            
+        # Construct the prompt for Gemini
+        prompt = f"""
+        Evaluate the following Python code solution for the challenge:
+        
+        Challenge: {challenge['title']}
+        Description: {challenge['description']}
+        
+        Test Cases:
+        {json.dumps(challenge['test_cases'], indent=2)}
+        
+        User's Solution:
+        ```python
+        {user_code}
+        ```
+        
+        Evaluate if the solution correctly solves the challenge based on the test cases.
+        Consider:
+        1. Correctness (does it produce the expected output for all test cases?)
+        2. Efficiency (is the solution reasonably efficient?)
+        3. Code quality (is the code well-structured and readable?)
+        
+        For each test case, indicate whether the solution passes or fails.
+        Provide a brief explanation of why it passes or fails.
+        Finally, provide an overall assessment: is the solution correct (pass all test cases)?
+        
+        Return your response in the following JSON format:
+        {{
+            "test_results": [
+                {{"test_case": "input", "expected": "output", "result": "pass/fail", "explanation": "brief explanation"}}
+            ],
+            "overall_assessment": "pass/fail",
+            "feedback": "brief feedback for the user",
+            "is_correct": true/false,
+            "code_quality_score": 1-10,
+            "algorithm_efficiency_score": 1-10
+        }}
+        
+        Ensure your response is valid JSON.
+        """
+        
+        # Generate content with Gemini
+        model = genai.GenerativeModel('gemini-1.5-pro')
+        response = model.generate_content(prompt)
+        
+        # Parse the response
+        try:
+            result = json.loads(response.text)
+            return result
+        except json.JSONDecodeError:
+            # If Gemini doesn't return valid JSON, provide a fallback response
+            return {
+                "test_results": [],
+                "overall_assessment": "Unable to evaluate",
+                "feedback": "There was an issue evaluating your code. Please try again.",
+                "is_correct": False,
+                "code_quality_score": 5,
+                "algorithm_efficiency_score": 5
+            }
+    
+    except Exception as e:
+        return {
+            "test_results": [],
+            "overall_assessment": f"Error: {str(e)}",
+            "feedback": "There was an error evaluating your code. Please check your syntax and try again.",
+            "is_correct": False,
+            "code_quality_score": 5,
+            "algorithm_efficiency_score": 5
+        }
+
+def adjust_difficulty_with_llm(user_code, evaluation, challenge):
+    """Use LLM to adjust difficulty based on code quality and approach"""
+    # Check if API key is available
+    if not GEMINI_API_KEY:
+        return fallback_difficulty_adjustment(evaluation.get("is_correct", False))
+        
+    # Store the solution in history
+    solution_entry = {
+        "challenge_id": challenge["id"],
+        "difficulty": user_data["difficulty_level"],
+        "code": user_code,
+        "is_correct": evaluation.get("is_correct", False),
+        "code_quality_score": evaluation.get("code_quality_score", 5),
+        "algorithm_efficiency_score": evaluation.get("algorithm_efficiency_score", 5)
+    }
+    user_data["solution_history"].append(solution_entry)
+    
+    # Format the prompt for Gemini
+    prompt = f"""
+    Analyze the user's solution and programming skill level to recommend an appropriate difficulty level.
+    
+    Current Difficulty Level: {user_data["difficulty_level"]}
+    Challenge: {challenge["title"]}
+    Description: {challenge["description"]}
+    
+    User's Solution:
+    ```python
+    {user_code}
+    ```
+    
+    Evaluation Summary:
+    - Correctness: {"Correct" if evaluation.get("is_correct", False) else "Incorrect"}
+    - Code Quality Score: {evaluation.get("code_quality_score", 5)}/10
+    - Algorithm Efficiency Score: {evaluation.get("algorithm_efficiency_score", 5)}/10
+    
+    User's History:
+    - Total Attempts: {user_data["total_attempts"]}
+    - Correct Solutions: {user_data["correct_answers"]}
+    - Success Rate: {user_data["correct_answers"] / user_data["total_attempts"] if user_data["total_attempts"] > 0 else 0:.2%}
+    
+    Based on this information, recommend the next difficulty level (easy, medium, or hard).
+    Consider the following factors:
+    1. Whether the solution is correct
+    2. The quality and efficiency of the code
+    3. The user's historical performance
+    4. The current difficulty level
+    
+    Provide your recommendation in the following JSON format:
+    {{
+        "recommended_difficulty": "easy/medium/hard",
+        "explanation": "brief explanation for the recommendation",
+        "skill_assessment": "brief assessment of the user's skill level"
+    }}
+    
+    Ensure your response is valid JSON.
+    """
+    
+    try:
+        # Generate content with Gemini
+        model = genai.GenerativeModel('gemini-1.5-pro')
+        response = model.generate_content(prompt)
+        
+        # Parse the response
+        try:
+            result = json.loads(response.text)
+            old_difficulty = user_data["difficulty_level"]
+            user_data["difficulty_level"] = result.get("recommended_difficulty", old_difficulty)
+            
+            # Ensure the difficulty is valid
+            if user_data["difficulty_level"] not in ["easy", "medium", "hard"]:
+                user_data["difficulty_level"] = old_difficulty
+                
+            return result
+        except json.JSONDecodeError:
+            # If Gemini doesn't return valid JSON, use a fallback approach
+            return fallback_difficulty_adjustment(evaluation.get("is_correct", False))
+    
+    except Exception as e:
+        return {
+            "recommended_difficulty": user_data["difficulty_level"],
+            "explanation": f"Error in difficulty adjustment: {str(e)}. Maintaining current difficulty.",
+            "skill_assessment": "Unable to assess skill level due to an error."
+        }
+
+def fallback_difficulty_adjustment(is_correct):
+    """Fallback method to adjust difficulty based on success rate"""
+    if is_correct:
+        user_data["correct_answers"] += 1
+    user_data["total_attempts"] += 1
+    
+    # Calculate success rate
+    success_rate = user_data["correct_answers"] / user_data["total_attempts"] if user_data["total_attempts"] > 0 else 0
+    
+    # Adjust difficulty based on success rate
+    current_level = user_data["difficulty_level"]
+    old_level = current_level
+    
+    if success_rate > 0.7 and current_level == "easy":
+        user_data["difficulty_level"] = "medium"
+    elif success_rate > 0.7 and current_level == "medium":
+        user_data["difficulty_level"] = "hard"
+    elif success_rate < 0.3 and current_level == "hard":
+        user_data["difficulty_level"] = "medium"
+    elif success_rate < 0.3 and current_level == "medium":
+        user_data["difficulty_level"] = "easy"
+    
+    return {
+        "recommended_difficulty": user_data["difficulty_level"],
+        "explanation": f"Based on your success rate of {success_rate:.2%}, {'increasing' if user_data['difficulty_level'] != old_level and 'easy' in old_level else 'decreasing' if user_data['difficulty_level'] != old_level else 'maintaining'} difficulty.",
+        "skill_assessment": "Skill assessment based on success rate only."
+    }
+
+def handle_submission(user_code):
+    """Handle user code submission"""
+    if not user_data["current_challenge"]:
+        return "Please get a challenge first."
+    
+    challenge = user_data["current_challenge"]
+    
+    # Evaluate the code
+    evaluation = evaluate_code_with_gemini(user_code, challenge)
+    
+    # Track correctness
+    is_correct = evaluation.get("is_correct", False)
+    if is_correct:
+        user_data["correct_answers"] += 1
+    user_data["total_attempts"] += 1
+    
+    # Adjust difficulty using LLM
+    difficulty_adjustment = adjust_difficulty_with_llm(user_code, evaluation, challenge)
+    
+    # Format response
+    response = f"## Evaluation Results\n\n"
+    response += f"**Challenge:** {challenge['title']}\n\n"
+    
+    if "test_results" in evaluation and evaluation["test_results"]:
+        response += "**Test Results:**\n"
+        for test in evaluation["test_results"]:
+            result = test.get("result", "N/A")
+            input_val = test.get("test_case", "N/A")
+            expected = test.get("expected", "N/A")
+            explanation = test.get("explanation", "N/A")
+            response += f"- Input: `{input_val}`, Expected: `{expected}`, Result: **{result}**\n"
+            response += f"  {explanation}\n\n"
+    
+    response += f"**Overall Assessment:** {evaluation.get('overall_assessment', 'N/A')}\n\n"
+    response += f"**Code Quality:** {evaluation.get('code_quality_score', 'N/A')}/10\n"
+    response += f"**Algorithm Efficiency:** {evaluation.get('algorithm_efficiency_score', 'N/A')}/10\n\n"
+    response += f"**Feedback:** {evaluation.get('feedback', 'N/A')}\n\n"
+    
+    response += f"**Difficulty Adjustment:**\n"
+    response += f"- New Difficulty: {difficulty_adjustment.get('recommended_difficulty', user_data['difficulty_level'])}\n"
+    response += f"- Reason: {difficulty_adjustment.get('explanation', 'N/A')}\n"
+    response += f"- Skill Assessment: {difficulty_adjustment.get('skill_assessment', 'N/A')}\n"
+    
+    return response
+
+def display_challenge():
+    """Get and display a challenge"""
+    challenge = get_challenge()
+    
+    response = f"## {challenge['title']}\n\n"
+    response += f"**Difficulty:** {user_data['difficulty_level']}\n\n"
+    response += f"**Description:** {challenge['description']}\n\n"
+    response += f"**Example Input:** {challenge['example_input']}\n"
+    response += f"**Example Output:** {challenge['example_output']}\n\n"
+    response += "Write your solution in Python and submit it when ready."
+    
+    return response
+
+def reset_session():
+    """Reset the user session"""
+    user_data["current_challenge"] = None
+    user_data["difficulty_level"] = "easy"
+    user_data["correct_answers"] = 0
+    user_data["total_attempts"] = 0
+    user_data["solution_history"] = []
+    return "Session reset. Your progress has been cleared and difficulty has been reset to easy."
+
+def check_api_key():
+    """Check if the API key is properly configured"""
+    if not GEMINI_API_KEY:
+        return gr.Markdown("""
+        ## ⚠️ API Key Not Found
+        
+        The Gemini API key is not configured. Please add it in the Space secrets with the name `GEMINI_API_KEY`.
+        
+        ### How to add a secret:
+        1. Go to the Settings tab on your Space
+        2. Navigate to the "Repository secrets" section
+        3. Add a new secret with the name `GEMINI_API_KEY` and your API key as the value
+        4. Restart the Space
+        """)
+    else:
+        return gr.Markdown("# LLM-Adaptive Python Coding Challenge\nThis application provides Python coding challenges that adapt to your skill level using AI.")
+
+# Set up the Gradio interface
+with gr.Blocks(title="LLM-Adaptive Python Coding Challenge", theme=gr.themes.Base()) as app:
+    header = gr.Markdown("Checking API configuration...")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            challenge_display = gr.Markdown("Click 'Get Challenge' to start")
+            
+            with gr.Row():
+                get_challenge_btn = gr.Button("Get Challenge")
+                reset_btn = gr.Button("Reset Progress")
+            
+            code_input = gr.Code(language="python", lines=15, label="Your Solution")
+            submit_btn = gr.Button("Submit Solution")
+            
+        with gr.Column(scale=3):
+            result_display = gr.Markdown("Results will appear here")
+    
+    gr.Markdown("### How it works")
+    gr.Markdown("1. Get a challenge by clicking 'Get Challenge'")
+    gr.Markdown("2. Write your solution in Python")
+    gr.Markdown("3. Submit your solution for evaluation")
+    gr.Markdown("4. The AI will analyze your code and adjust the difficulty based on your coding style, efficiency, and correctness")
+    
+    # Check API key on load
+    app.load(check_api_key, [], [header])
+    
+    get_challenge_btn.click(display_challenge, inputs=[], outputs=challenge_display)
+    reset_btn.click(reset_session, inputs=[], outputs=result_display)
+    submit_btn.click(handle_submission, inputs=[code_input], outputs=result_display)
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()