app.py

import gradio as gr
import numpy as np
import pandas as pd
from typing import Dict
import time
from sklearn.metrics import accuracy_score, mean_squared_error, classification_report
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# Additional ML helper functions
def evaluate_ml_solution(y_true, y_pred, task_type='classification'):
    """Evaluate ML model predictions"""
    if task_type == 'classification':
        accuracy = accuracy_score(y_true, y_pred)
        report = classification_report(y_true, y_pred)
        return f"Accuracy: {accuracy:.4f}\n\nDetailed Report:\n{report}"
    else:
        mse = mean_squared_error(y_true, y_pred)
        rmse = np.sqrt(mse)
        return f"MSE: {mse:.4f}\nRMSE: {rmse:.4f}"

# Extended problem set including ML problems
PROBLEM_DATA = {
    # Original Algorithm Problems
    "Valid Parentheses": {
        "type": "algorithm",
        "difficulty": "easy",
        "description": "Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.",
        "test_cases": [
            {'input': "()", 'expected': True},
            {'input': "()[]{}", 'expected': True},
            {'input': "(]", 'expected': False}
        ],
        "sample_input": "()",
        "starter_code": """def solution(s: str) -> bool:
    # Write your solution here
    pass"""
    },
    
    # ML Classification Problem
    "Binary Classification": {
        "type": "ml_classification",
        "difficulty": "medium",
        "description": "Create a binary classifier for the provided dataset. Features include numerical values, target is binary (0/1).",
        "test_cases": [
            {
                'input': pd.DataFrame({
                    'feature1': [1.2, 2.3, 3.4, 4.5],
                    'feature2': [2.1, 3.2, 4.3, 5.4]
                }),
                'expected': np.array([0, 1, 1, 0])
            }
        ],
        "starter_code": """class MLSolution:
    def __init__(self):
        self.model = None
    
    def fit(self, X, y):
        # Implement training logic
        pass
    
    def predict(self, X):
        # Implement prediction logic
        return np.zeros(len(X))"""
    },
    
    # Neural Network Problem
    "Simple Neural Network": {
        "type": "deep_learning",
        "difficulty": "hard",
        "description": "Implement a simple neural network for binary classification using PyTorch.",
        "test_cases": [
            {
                'input': torch.randn(10, 5),  # 10 samples, 5 features
                'expected': torch.randint(0, 2, (10,))
            }
        ],
        "starter_code": """class NeuralNetwork(nn.Module):
    def __init__(self, input_size):
        super(NeuralNetwork, self).__init__()
        self.layer1 = nn.Linear(input_size, 64)
        self.layer2 = nn.Linear(64, 1)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        x = torch.relu(self.layer1(x))
        x = self.sigmoid(self.layer2(x))
        return x"""
    },
    
    # Regression Problem
    "House Price Prediction": {
        "type": "ml_regression",
        "difficulty": "medium",
        "description": "Implement a regression model to predict house prices based on features like size, location, etc.",
        "test_cases": [
            {
                'input': pd.DataFrame({
                    'size': [1500, 2000, 2500],
                    'rooms': [3, 4, 5],
                    'location_score': [8, 7, 9]
                }),
                'expected': np.array([250000, 300000, 400000])
            }
        ],
        "starter_code": """class RegressionSolution:
    def __init__(self):
        self.model = None
        
    def fit(self, X, y):
        # Implement training logic
        pass
        
    def predict(self, X):
        # Implement prediction logic
        return np.zeros(len(X))"""
    }
}

def create_sample_data(problem_type: str) -> Dict:
    """Create sample datasets for ML problems"""
    if problem_type == 'ml_classification':
        X_train = pd.DataFrame(np.random.randn(100, 2), columns=['feature1', 'feature2'])
        y_train = np.random.randint(0, 2, 100)
        X_test = pd.DataFrame(np.random.randn(20, 2), columns=['feature1', 'feature2'])
        y_test = np.random.randint(0, 2, 20)
        return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test}
    
    elif problem_type == 'ml_regression':
        X_train = pd.DataFrame(np.random.randn(100, 3), 
                             columns=['size', 'rooms', 'location_score'])
        y_train = np.random.uniform(200000, 500000, 100)
        X_test = pd.DataFrame(np.random.randn(20, 3), 
                            columns=['size', 'rooms', 'location_score'])
        y_test = np.random.uniform(200000, 500000, 20)
        return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test}
    
    elif problem_type == 'deep_learning':
        # Generate sample data for neural network
        X_train = torch.randn(100, 5)  # 100 samples, 5 features
        y_train = torch.randint(0, 2, (100,))  # Binary classification
        X_test = torch.randn(20, 5)  # 20 samples, 5 features
        y_test = torch.randint(0, 2, (20,))  # Binary classification
        return {'X_train': X_train, 'y_train': y_train, 'X_test': X_test, 'y_test': y_test}
    
    return None

def run_tests(problem_name: str, user_code: str) -> str:
    try:
        problem = PROBLEM_DATA[problem_name]
        
        if problem["type"] == "algorithm":
            # Execute algorithm problems
            namespace = {}
            exec(user_code, namespace)
            results = []
            
            for i, test in enumerate(problem["test_cases"], 1):
                try:
                    start_time = time.time()
                    output = namespace["solution"](test["input"])
                    execution_time = time.time() - start_time
                    
                    passed = output == test["expected"]
                    results.append(
                        f"Test #{i}:\n"
                        f"Input: {test['input']}\n"
                        f"Expected: {test['expected']}\n"
                        f"Got: {output}\n"
                        f"Time: {execution_time:.6f}s\n"
                        f"Status: {'✓ PASSED' if passed else '✗ FAILED'}\n"
                    )
                except Exception as e:
                    results.append(f"Test #{i} Error: {str(e)}\n")
                    
            return "\n".join(results)
            
        else:
            # Execute ML problems
            namespace = {"np": np, "pd": pd, "nn": nn, "torch": torch}
            exec(user_code, namespace)
            
            # Create sample data
            data = create_sample_data(problem["type"])
            if not data:
                return "Error: Invalid problem type"
                
            try:
                if problem["type"] in ["ml_classification", "ml_regression"]:
                    # Initialize and train model
                    model = namespace["MLSolution"]()
                    model.fit(data["X_train"], data["y_train"])
                    
                    # Make predictions
                    predictions = model.predict(data["X_test"])
                    
                    # Evaluate
                    eval_result = evaluate_ml_solution(
                        data["y_test"], 
                        predictions,
                        "classification" if problem["type"] == "ml_classification" else "regression"
                    )
                    
                    return f"Model Evaluation:\n{eval_result}"
                    
                elif problem["type"] == "deep_learning":
                    # Initialize neural network
                    model = namespace["NeuralNetwork"](data["X_train"].shape[1])
                    criterion = nn.BCELoss()  # Binary cross-entropy loss
                    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
                    
                    # Convert data to tensors
                    X_train = data["X_train"].float()
                    y_train = data["y_train"].float().view(-1, 1)
                    X_test = data["X_test"].float()
                    y_test = data["y_test"].float().view(-1, 1)
                    
                    # Train the model
                    for epoch in range(10):  # 10 epochs
                        optimizer.zero_grad()
                        outputs = model(X_train)
                        loss = criterion(outputs, y_train)
                        loss.backward()
                        optimizer.step()
                    
                    # Evaluate the model
                    with torch.no_grad():
                        predictions = model(X_test)
                        predictions = (predictions > 0.5).float()  # Convert probabilities to binary predictions
                        accuracy = (predictions == y_test).float().mean()
                    
                    return f"Neural Network Evaluation:\nAccuracy: {accuracy.item():.4f}"
                    
            except Exception as e:
                return f"Error in ML execution: {str(e)}"
                
    except Exception as e:
        return f"Error in code execution: {str(e)}"

# Create Gradio interface with enhanced features
def create_interface():
    with gr.Blocks(title="Advanced LeetCode & ML Testing Platform") as iface:  
        # All components and event handlers must be defined within this 'with' block
        gr.Markdown("# Advanced LeetCode & ML Testing Platform")
        
        with gr.Tabs():
            with gr.Tab("Problem Solving"):
                problem_dropdown = gr.Dropdown(
                    choices=list(PROBLEM_DATA.keys()),
                    label="Select Problem"
                )
                difficulty_display = gr.Textbox(label="Difficulty")
                problem_type = gr.Textbox(label="Problem Type")
                description_text = gr.Textbox(label="Description", lines=5)
                code_input = gr.Textbox(label="Your Code", lines=10, value="")
                results_output = gr.Textbox(label="Test Results", value="", lines=10)

                with gr.Row():
                    run_button = gr.Button("Run Tests")
                    clear_button = gr.Button("Clear Code")
                    
                # Event handler for Run Tests button (inside Blocks context)
                run_button.click(
                    run_tests,
                    inputs=[problem_dropdown, code_input],
                    outputs=[results_output]
                )

                # Event handler for Clear Code button (inside Blocks context)
                clear_button.click(
                    lambda: "",
                    inputs=[],
                    outputs=[code_input]
                )

                # Event handler for problem selection (inside Blocks context)
                def update_problem_info(problem_name):
                    problem = PROBLEM_DATA[problem_name]
                    return (
                        problem["difficulty"],
                        problem["type"],
                        problem["description"],
                        problem["starter_code"],
                        ""  # Clear results
                    )

                problem_dropdown.change(
                    update_problem_info,
                    inputs=[problem_dropdown],
                    outputs=[
                        difficulty_display,
                        problem_type,
                        description_text,
                        code_input,
                        results_output
                    ]
                )
                
            with gr.Tab("Visualization"):
                with gr.Row():
                    plot_type = gr.Dropdown(
                        choices=["Learning Curve", "Confusion Matrix", "Feature Importance"],
                        label="Select Plot Type"
                    )
                    visualize_button = gr.Button("Generate Visualization")
                
                plot_output = gr.Plot(label="Visualization")

                # Event handler for visualization
                def generate_visualization(plot_type):
                    if plot_type == "Learning Curve":
                        # Example learning curve
                        plt.figure()
                        plt.plot([0, 1, 2, 3, 4], [0.8, 0.7, 0.6, 0.5, 0.4], label="Training Loss")
                        plt.plot([0, 1, 2, 3, 4], [0.9, 0.8, 0.7, 0.6, 0.5], label="Validation Loss")
                        plt.xlabel("Epochs")
                        plt.ylabel("Loss")
                        plt.title("Learning Curve")
                        plt.legend()
                        return plt
                    else:
                        return None

                visualize_button.click(
                    generate_visualization,
                    inputs=[plot_type],
                    outputs=[plot_output]
                )

    return iface


if __name__ == "__main__":
    iface = create_interface()
    iface.launch()