125 lines
4.5 KiB
Python
125 lines
4.5 KiB
Python
from markupsafe import Markup
|
|
from flask import Flask, render_template, request, redirect, url_for, send_from_directory
|
|
import markdown as md
|
|
|
|
from models import db, Problem, Solution
|
|
from utils import run_code_against_tests
|
|
from leaderboard import create_leaderboard_table, log_leaderboard, get_leaderboard
|
|
|
|
|
|
import os
|
|
## from problem_loader import load_problems_from_json, schedule_problem_reload
|
|
from problem_scanner import start_problem_scanner
|
|
import sqlite3
|
|
from pathlib import Path
|
|
|
|
app = Flask(__name__)
|
|
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite3'
|
|
db.init_app(app)
|
|
|
|
|
|
|
|
@app.before_request
|
|
def setup():
|
|
db.create_all()
|
|
create_leaderboard_table() # Ensure leaderboard table exists
|
|
# Problems are now loaded from manifests by the background scanner. No need to load problems.json.
|
|
|
|
# Start the background thread to scan problems
|
|
start_problem_scanner()
|
|
|
|
@app.route("/script.js")
|
|
def script():
|
|
return send_from_directory("templates", "script.js")
|
|
|
|
@app.route('/favicon.ico')
|
|
def favicon():
|
|
return send_from_directory("templates", "favicon", "favicon.ico")
|
|
|
|
@app.route('/')
|
|
def index():
|
|
db_path = Path(__file__).parent / 'problems.sqlite3'
|
|
conn = sqlite3.connect(db_path)
|
|
c = conn.cursor()
|
|
c.execute('SELECT folder, description, test_code FROM problems')
|
|
problems = c.fetchall()
|
|
conn.close()
|
|
# Get leaderboard entries
|
|
leaderboard = get_leaderboard()
|
|
# Map folder to title for display
|
|
problem_titles = {folder: folder.replace('_', ' ').title() for folder, _, _ in problems}
|
|
return render_template('index.html', problems=problems, leaderboard=leaderboard, problem_titles=problem_titles)
|
|
|
|
@app.route('/problem/new', methods=['GET', 'POST'])
|
|
def new_problem():
|
|
if request.method == 'POST':
|
|
title = request.form['title']
|
|
description = request.form['description']
|
|
test_code = request.form['test_code']
|
|
problem = Problem(title=title, description=description, test_code=test_code)
|
|
db.session.add(problem)
|
|
db.session.commit()
|
|
return redirect(url_for('index'))
|
|
return render_template('new_problem.html')
|
|
|
|
@app.route('/problem/<folder>', methods=['GET', 'POST'])
|
|
def view_problem(folder):
|
|
db_path = Path(__file__).parent / 'problems.sqlite3'
|
|
conn = sqlite3.connect(db_path)
|
|
c = conn.cursor()
|
|
c.execute('SELECT folder, description, test_code FROM problems WHERE folder = ?', (folder,))
|
|
row = c.fetchone()
|
|
conn.close()
|
|
if not row:
|
|
return 'Problem not found', 404
|
|
problem = {
|
|
'folder': row[0],
|
|
'description': row[1],
|
|
'test_code': row[2],
|
|
'title': row[0].replace('_', ' ').title()
|
|
}
|
|
result = None
|
|
if request.method == 'POST':
|
|
user_code = request.form['user_code']
|
|
username = request.form.get('username', '').strip() or 'Anonymous'
|
|
import tracemalloc
|
|
tracemalloc.start()
|
|
run_result = run_code_against_tests(user_code, problem['test_code'])
|
|
current, peak = tracemalloc.get_traced_memory()
|
|
tracemalloc.stop()
|
|
memory_used = peak // 1024 # in KB
|
|
# Try to get the last line number executed (even for successful runs)
|
|
line_number = None
|
|
import ast
|
|
try:
|
|
tree = ast.parse(user_code)
|
|
# Find the highest line number in the AST (for multi-function/user code)
|
|
def get_max_lineno(node):
|
|
max_lineno = getattr(node, 'lineno', 0)
|
|
for child in ast.iter_child_nodes(node):
|
|
max_lineno = max(max_lineno, get_max_lineno(child))
|
|
return max_lineno
|
|
line_number = get_max_lineno(tree)
|
|
except Exception:
|
|
pass
|
|
# If there was an error, try to get the error line number from the traceback
|
|
if run_result['error']:
|
|
tb = run_result['error']
|
|
import traceback
|
|
try:
|
|
tb_lines = traceback.extract_tb(traceback.TracebackException.from_string(tb).stack)
|
|
if tb_lines:
|
|
line_number = tb_lines[-1].lineno
|
|
except Exception:
|
|
pass
|
|
log_leaderboard(username, problem['folder'], run_result['runtime'], memory_used, line_number)
|
|
result = run_result
|
|
return render_template('problem.html', problem=problem, result=result)
|
|
|
|
@app.template_filter('markdown')
|
|
def markdown_filter(text):
|
|
return Markup(md.markdown(text or '', extensions=['extra', 'sane_lists']))
|
|
|
|
if __name__ == '__main__':
|
|
app.run(debug=True)
|