app.py

import gradio as gr
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import random
import json
from typing import Dict, List, Optional
import numpy as np
import hashlib
import datetime
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

class UserManager:
    def __init__(self):
        # Use a simple in-memory dictionary instead of Firebase
        self.users = {}
        self.progress = {}
    
    def register_user(self, username: str, password: str) -> bool:
        if username in self.users:
            return False
        
        # Hash password
        hashed_password = hashlib.sha256(password.encode()).hexdigest()
        
        # Store user data
        self.users[username] = {
            'password_hash': hashed_password,
            'join_date': datetime.datetime.now(),
            'solved_problems': [],
            'skill_level': 'beginner'
        }
        self.progress[username] = {
            'arrays': 0,
            'graphs': 0,
            'dynamic_programming': 0,
            'trees': 0
        }
        return True
    
    def authenticate(self, username: str, password: str) -> bool:
        if username not in self.users:
            return False
        
        hashed_password = hashlib.sha256(password.encode()).hexdigest()
        return self.users[username]['password_hash'] == hashed_password
    
    def update_progress(self, username: str, topic: str, success: bool):
        if success:
            self.progress[username][topic] += 1
        
        # Update skill level based on progress
        total_solved = sum(self.progress[username].values())
        if total_solved > 50:
            self.users[username]['skill_level'] = 'advanced'
        elif total_solved > 20:
            self.users[username]['skill_level'] = 'intermediate'

class EnhancedProblemGenerator:
    def __init__(self):
        self.templates = {
            "arrays": [
                {
                    "title": "Two Sum",
                    "difficulty": "Easy",
                    "description": "Given an array of integers nums and an integer target, return indices of the two numbers that add up to target.",
                    "constraints": ["2 <= nums.length <= 104", "-109 <= nums[i] <= 109"],
                    "test_cases": [
                        {"input": "[2,7,11,15], target=9", "output": "[0,1]"},
                        {"input": "[3,2,4], target=6", "output": "[1,2]"}
                    ],
                    "hints": [
                        "Consider using a hash map to store previously seen numbers",
                        "Think about the complement of each number relative to the target"
                    ]
                },
                {
                    "title": "Maximum Subarray",
                    "difficulty": "Easy",
                    "description": "Find the contiguous subarray with the largest sum.",
                    "constraints": ["1 <= nums.length <= 105", "-104 <= nums[i] <= 104"],
                    "test_cases": [
                        {"input": "[-2,1,-3,4,-1,2,1,-5,4]", "output": "6"},
                        {"input": "[1]", "output": "1"}
                    ],
                    "hints": [
                        "Consider Kadane's algorithm",
                        "Think about when to reset your current sum"
                    ]
                }
            ],
            "dynamic_programming": [
                {
                    "title": "Climbing Stairs",
                    "difficulty": "Easy",
                    "description": "You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?",
                    "constraints": ["1 <= n <= 45"],
                    "test_cases": [
                        {"input": "2", "output": "2"},
                        {"input": "3", "output": "3"}
                    ],
                    "hints": [
                        "Think about the Fibonacci sequence",
                        "Consider the last step you take"
                    ]
                }
            ],
            "trees": [
                {
                    "title": "Maximum Depth of Binary Tree",
                    "difficulty": "Easy",
                    "description": "Given the root of a binary tree, return its maximum depth.",
                    "constraints": ["The number of nodes in the tree is in the range [0, 104]"],
                    "test_cases": [
                        {"input": "[3,9,20,null,null,15,7]", "output": "3"},
                        {"input": "[1,null,2]", "output": "2"}
                    ],
                    "hints": [
                        "Consider using recursion",
                        "Think about the base case of an empty tree"
                    ]
                }
            ]
        }
        
        # Load AI model for hint generation
        self.tokenizer = AutoTokenizer.from_pretrained("microsoft/CodeGPT-small-py")
        self.model = AutoModelForCausalLM.from_pretrained("microsoft/CodeGPT-small-py")
    
    def generate_ai_hint(self, problem: Dict, user_code: str) -> str:
        prompt = f"""
Problem: {problem['description']}
User's code: {user_code}
Hint: Let me help you think about this problem. 
"""
        inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
        outputs = self.model.generate(**inputs, max_length=200, num_return_sequences=1)
        hint = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        return hint.split("Hint: ")[-1].strip()
    
    def get_problem_for_user(self, username: str, user_manager: UserManager, topic: str) -> Dict:
        user_level = user_manager.users[username]['skill_level']
        available_problems = self.templates.get(topic.lower(), [])
        
        if not available_problems:
            return {"error": "Topic not found"}
        
        # Filter problems based on user level
        if user_level == 'beginner':
            problems = [p for p in available_problems if p['difficulty'] == 'Easy']
        elif user_level == 'intermediate':
            problems = [p for p in available_problems if p['difficulty'] in ['Easy', 'Medium']]
        else:
            problems = available_problems
        
        return random.choice(problems)

class EnhancedCodeEvaluator:
    def __init__(self):
        self.test_environment = {}
    
    def analyze_complexity(self, code: str) -> str:
        # Simple complexity analysis based on nested loops
        if "while" not in code and "for" not in code:
            return "O(1)"
        elif code.count("for") + code.count("while") == 1:
            return "O(n)"
        elif code.count("for") + code.count("while") == 2:
            return "O(n²)"
        else:
            return "O(n³) or higher"
    
    def evaluate_code(self, code: str, test_cases: List[Dict]) -> Dict:
        try:
            # Create safe execution environment
            local_dict = {}
            exec(code, {"__builtins__": {}}, local_dict)
            
            results = []
            passed = 0
            
            for test in test_cases:
                try:
                    # Execute test case
                    test_result = eval(f"solution{test['input']}", local_dict)
                    expected = eval(test['output'])
                    
                    if test_result == expected:
                        passed += 1
                        results.append({"status": "PASS", "input": test['input']})
                    else:
                        results.append({
                            "status": "FAIL",
                            "input": test['input'],
                            "expected": expected,
                            "got": test_result
                        })
                except Exception as e:
                    results.append({
                        "status": "ERROR",
                        "input": test['input'],
                        "error": str(e)
                    })
            
            # Analyze code complexity
            complexity = self.analyze_complexity(code)
            
            return {
                "success": True,
                "results": results,
                "passed": passed,
                "total": len(test_cases),
                "complexity": complexity
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": str(e)
            }

class EnhancedLeetCodeEducator:
    def __init__(self):
        self.problem_generator = EnhancedProblemGenerator()
        self.code_evaluator = EnhancedCodeEvaluator()
        self.user_manager = UserManager()
        
        # Check for GPU availability
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        print(f"Using device: {self.device}")
        
        # Initialize hint generator
        self.hint_generator = pipeline("text-generation", model="microsoft/CodeGPT-small-py")
    
    def register_user(self, username: str, password: str) -> str:
        if self.user_manager.register_user(username, password):
            return f"Successfully registered user: {username}"
        return "Username already exists"
    
    def login(self, username: str, password: str) -> bool:
        return self.user_manager.authenticate(username, password)
    
    def get_problem(self, username: str, topic: str) -> str:
        if not self.user_manager.authenticate(username, ""):  # Check if user exists
            return "Please log in first"
        
        problem = self.problem_generator.get_problem_for_user(username, self.user_manager, topic)
        if "error" in problem:
            return "Topic not found. Available topics: arrays, graphs, dynamic_programming, trees"
        
        return f"""
Problem: {problem['title']}
Difficulty: {problem['difficulty']}

Description:
{problem['description']}

Constraints:
{chr(10).join(['- ' + c for c in problem['constraints']])}

Example Test Cases:
{chr(10).join([f'Input: {tc["input"]}, Output: {tc["output"]}' for tc in problem['test_cases']])}

Your current skill level: {self.user_manager.users[username]['skill_level']}
Problems solved in this topic: {self.user_manager.progress[username][topic]}
"""
    
    def get_hint(self, username: str, topic: str, code: str) -> str:
        if not self.user_manager.authenticate(username, ""):
            return "Please log in first"
        
        problem = self.problem_generator.get_problem_for_user(username, self.user_manager, topic)
        if "error" in problem:
            return "Cannot generate hint: problem not found"
        
        if not code:
            # If no code provided, return a general hint
            return random.choice(problem['hints'])
        
        # Generate personalized hint based on user's code
        return self.problem_generator.generate_ai_hint(problem, code)
    
    def evaluate_submission(self, username: str, code: str, topic: str) -> str:
        if not self.user_manager.authenticate(username, ""):
            return "Please log in first"
        
        problem = self.problem_generator.get_problem_for_user(username, self.user_manager, topic)
        if "error" in problem:
            return "Error: Could not find problem for evaluation"
        
        results = self.code_evaluator.evaluate_code(code, problem['test_cases'])
        
        if not results['success']:
            return f"Error in code execution: {results['error']}"
        
        # Update user progress
        self.user_manager.update_progress(username, topic, results['passed'] == results['total'])
        
        output = f"""
Evaluation Results:
Passed: {results['passed']}/{results['total']} test cases
Time Complexity: {results['complexity']}

Details:
"""
        for idx, result in enumerate(results['results']):
            output += f"\nTest Case {idx + 1}: {result['status']}"
            if result['status'] == 'FAIL':
                output += f"\n  Expected: {result['expected']}"
                output += f"\n  Got: {result['got']}"
            elif result['status'] == 'ERROR':
                output += f"\n  Error: {result['error']}"
        
        if results['passed'] < results['total']:
            output += f"\n\nNeed a hint? Type 'hint' in the code box to get personalized help!"
        
        return output

def create_enhanced_gradio_interface():
    educator = EnhancedLeetCodeEducator()
    
    def process_interaction(username, password, action, topic, code):
        if action == "Register":
            return educator.register_user(username, password)
        elif action == "Login":
            if educator.login(username, password):
                return "Login successful!"
            return "Invalid credentials"
        elif action == "Get Problem":
            return educator.get_problem(username, topic)
        elif action == "Submit Solution":
            if code.strip().lower() == "hint":
                return educator.get_hint(username, topic, "")
            else:
                return educator.evaluate_submission(username, code, topic)
        else:
            return "Invalid action selected."
    
    # Create the interface
    iface = gr.Interface(
        fn=process_interaction,
        inputs=[
            gr.Textbox(label="Username"),
            gr.Textbox(label="Password", type="password"),
            gr.Radio(
                choices=["Register", "Login", "Get Problem", "Submit Solution"],
                label="Action",
                value="Register"
            ),
            gr.Dropdown(
                choices=["arrays", "dynamic_programming", "trees"],
                label="Topic",
                value="arrays"
            ),
            gr.Code(language="python", label="Your Solution (type 'hint' for help)")
        ],
        outputs=gr.Textbox(label="Output", lines=10),
        title="Enhanced LeetCode Educational Assistant",
        description="""
        Welcome to your personalized coding practice platform!
        
        1. Register or login to get started
        2. Choose a topic and get a problem
        3. Write your solution or type 'hint' for help
        4. Submit your code for evaluation
        
        Your progress is tracked and problems are tailored to your skill level!
        """,
        examples=[
            ["new_user", "password123", "Register", "arrays", ""],
            ["new_user", "password123", "Login", "arrays", ""],
            ["new_user", "password123", "Get Problem", "arrays", ""],
            ["new_user", "password123", "Submit Solution", "arrays", "def solution(nums, target):\n    seen = {}\n    for i, num in enumerate(nums):\n        complement = target - num\n        if complement in seen:\n            return [seen[complement], i]\n        seen[num] = i\n    return []"]
        ],
        theme="default"
    )
    
    return iface

# Create and launch the interface
interface = create_enhanced_gradio_interface()
interface.launch()