zajebis
This commit is contained in:
384
src/problem_scanner.py
Normal file
384
src/problem_scanner.py
Normal file
@@ -0,0 +1,384 @@
|
||||
import os
|
||||
import time
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
import random
|
||||
import tempfile
|
||||
import subprocess
|
||||
import sys
|
||||
import traceback
|
||||
import io
|
||||
from pathlib import Path
|
||||
|
||||
try:
|
||||
from watchdog.observers import Observer
|
||||
from watchdog.events import FileSystemEventHandler
|
||||
WATCHDOG_AVAILABLE = True
|
||||
except ImportError:
|
||||
WATCHDOG_AVAILABLE = False
|
||||
|
||||
PROBLEMS_DIR = Path(__file__).parent / 'problems'
|
||||
DB_PATH = Path(__file__).parent / 'database/problems.sqlite3'
|
||||
|
||||
class ProblemScannerThread(threading.Thread):
|
||||
def __init__(self, scan_interval=2):
|
||||
super().__init__(daemon=True)
|
||||
self.scan_interval = scan_interval
|
||||
self.last_state = {}
|
||||
self.observer = None
|
||||
|
||||
def create_table(self, conn):
|
||||
c = conn.cursor()
|
||||
c.execute('PRAGMA journal_mode=WAL;')
|
||||
c.execute('''CREATE TABLE IF NOT EXISTS problems (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
folder TEXT,
|
||||
description TEXT,
|
||||
difficulty TEXT,
|
||||
test_code TEXT
|
||||
)''')
|
||||
conn.commit()
|
||||
|
||||
def scan(self):
|
||||
problems = []
|
||||
if not PROBLEMS_DIR.exists():
|
||||
print(f"Problems directory does not exist: {PROBLEMS_DIR}")
|
||||
return problems
|
||||
|
||||
for folder in PROBLEMS_DIR.iterdir():
|
||||
if folder.is_dir():
|
||||
# Dynamically find manifest file (manifest.json or manifets.json)
|
||||
manifest_path = None
|
||||
for candidate in ["manifest.json", "manifets.json"]:
|
||||
candidate_path = folder / candidate
|
||||
if candidate_path.exists():
|
||||
manifest_path = candidate_path
|
||||
break
|
||||
|
||||
desc_path = folder / 'description.md'
|
||||
test_path = folder / 'test.py'
|
||||
|
||||
# Check if required files exist
|
||||
if manifest_path and desc_path.exists() and test_path.exists():
|
||||
try:
|
||||
with open(desc_path, 'r', encoding='utf-8') as f:
|
||||
description = f.read()
|
||||
with open(test_path, 'r', encoding='utf-8') as f:
|
||||
test_code = f.read()
|
||||
with open(manifest_path, 'r', encoding='utf-8') as f:
|
||||
manifest = json.load(f)
|
||||
|
||||
difficulty = manifest.get('difficulty', 'unknown')
|
||||
|
||||
problems.append({
|
||||
'folder': folder.name,
|
||||
'description': description,
|
||||
'test_code': test_code,
|
||||
'difficulty': difficulty
|
||||
})
|
||||
print(f"Found problem: {folder.name} ; Difficulty: {difficulty}")
|
||||
except Exception as e:
|
||||
print(f"Error reading problem files for {folder.name}: {e}")
|
||||
else:
|
||||
missing_files = []
|
||||
if not manifest_path:
|
||||
missing_files.append("manifest.json/manifets.json")
|
||||
if not desc_path.exists():
|
||||
missing_files.append("description.md")
|
||||
if not test_path.exists():
|
||||
missing_files.append("test.py")
|
||||
print(f"Skipping {folder.name}: missing {', '.join(missing_files)}")
|
||||
|
||||
print(f"Total problems found: {len(problems)}")
|
||||
return problems
|
||||
|
||||
def update_db(self, problems, retries=5):
|
||||
for attempt in range(retries):
|
||||
try:
|
||||
conn = sqlite3.connect(DB_PATH, timeout=5)
|
||||
c = conn.cursor()
|
||||
c.execute('PRAGMA journal_mode=WAL;')
|
||||
|
||||
# Clear existing problems
|
||||
c.execute('DELETE FROM problems')
|
||||
|
||||
# Insert new problems
|
||||
for p in problems:
|
||||
c.execute('''INSERT INTO problems
|
||||
(folder, description, difficulty, test_code)
|
||||
VALUES (?, ?, ?, ?)''',
|
||||
(p['folder'], p['description'], p['difficulty'], p['test_code']))
|
||||
|
||||
conn.commit()
|
||||
print(f"Updated database with {len(problems)} problems")
|
||||
conn.close()
|
||||
return
|
||||
|
||||
except sqlite3.OperationalError as e:
|
||||
if 'locked' in str(e).lower():
|
||||
wait_time = 0.2 + random.random() * 0.3
|
||||
print(f"Database locked, retrying in {wait_time:.2f}s (attempt {attempt + 1})")
|
||||
time.sleep(wait_time)
|
||||
else:
|
||||
print(f"Database error: {e}")
|
||||
raise
|
||||
except Exception as e:
|
||||
print(f"Unexpected error updating database: {e}")
|
||||
raise
|
||||
|
||||
print('Failed to update problems DB after several retries due to lock.')
|
||||
|
||||
def rescan_and_update(self):
|
||||
print("Scanning for problems...")
|
||||
problems = self.scan()
|
||||
self.update_db(problems)
|
||||
|
||||
def run(self):
|
||||
print("Starting problem scanner...")
|
||||
|
||||
# Initial scan and table creation
|
||||
try:
|
||||
conn = sqlite3.connect(DB_PATH)
|
||||
self.create_table(conn)
|
||||
conn.close()
|
||||
print("Database initialized")
|
||||
except Exception as e:
|
||||
print(f"Failed to initialize database: {e}")
|
||||
return
|
||||
|
||||
# Initial scan
|
||||
self.rescan_and_update()
|
||||
|
||||
if WATCHDOG_AVAILABLE:
|
||||
print("Using watchdog for file monitoring")
|
||||
|
||||
class Handler(FileSystemEventHandler):
|
||||
def __init__(self, scanner):
|
||||
self.scanner = scanner
|
||||
self.last_event_time = 0
|
||||
|
||||
def on_any_event(self, event):
|
||||
# Debounce events to avoid too many rescans
|
||||
now = time.time()
|
||||
if now - self.last_event_time > 1: # Wait at least 1 second between rescans
|
||||
self.last_event_time = now
|
||||
print(f"File system event: {event.event_type} - {event.src_path}")
|
||||
self.scanner.rescan_and_update()
|
||||
|
||||
event_handler = Handler(self)
|
||||
self.observer = Observer()
|
||||
self.observer.schedule(event_handler, str(PROBLEMS_DIR), recursive=True)
|
||||
self.observer.start()
|
||||
|
||||
try:
|
||||
while True:
|
||||
time.sleep(1)
|
||||
except KeyboardInterrupt:
|
||||
print("Stopping problem scanner...")
|
||||
finally:
|
||||
self.observer.stop()
|
||||
self.observer.join()
|
||||
else:
|
||||
print(f"Watchdog not available, using polling every {self.scan_interval}s")
|
||||
# Fallback: poll every scan_interval seconds
|
||||
try:
|
||||
while True:
|
||||
time.sleep(self.scan_interval)
|
||||
self.rescan_and_update()
|
||||
except KeyboardInterrupt:
|
||||
print("Stopping problem scanner...")
|
||||
|
||||
def start_problem_scanner():
|
||||
scanner = ProblemScannerThread()
|
||||
scanner.start()
|
||||
return scanner
|
||||
|
||||
# Flask model loading functions
|
||||
def load_problems_from_json(json_path):
|
||||
"""Load problems from JSON file into Flask database"""
|
||||
if not os.path.exists(json_path):
|
||||
print(f"Problem JSON file not found: {json_path}")
|
||||
return
|
||||
|
||||
try:
|
||||
with open(json_path, 'r', encoding='utf-8') as f:
|
||||
problems = json.load(f)
|
||||
except Exception as e:
|
||||
print(f"Error reading JSON file: {e}")
|
||||
return
|
||||
|
||||
# This assumes you have imported the necessary Flask/SQLAlchemy components
|
||||
try:
|
||||
from models import db, Problem
|
||||
|
||||
for p in problems:
|
||||
# Check if problem already exists by title
|
||||
existing = Problem.query.filter_by(title=p['title']).first()
|
||||
|
||||
# Load test code from solution file if provided
|
||||
test_code = ''
|
||||
if 'solution' in p and os.path.exists(p['solution']):
|
||||
try:
|
||||
with open(p['solution'], 'r', encoding='utf-8') as sf:
|
||||
test_code = sf.read()
|
||||
except Exception as e:
|
||||
print(f"Error reading solution file for {p['title']}: {e}")
|
||||
|
||||
if existing:
|
||||
existing.description = p['description']
|
||||
existing.test_code = test_code
|
||||
print(f"Updated problem: {p['title']}")
|
||||
else:
|
||||
new_problem = Problem(title=p['title'], description=p['description'], test_code=test_code)
|
||||
db.session.add(new_problem)
|
||||
print(f"Added new problem: {p['title']}")
|
||||
|
||||
db.session.commit()
|
||||
print("Successfully updated problems from JSON")
|
||||
|
||||
except ImportError:
|
||||
print("Flask models not available - skipping JSON load")
|
||||
except Exception as e:
|
||||
print(f"Error loading problems from JSON: {e}")
|
||||
|
||||
def schedule_problem_reload(app, json_path, interval_hours=10):
|
||||
"""Schedule periodic reloading of problems from JSON"""
|
||||
def reload_loop():
|
||||
while True:
|
||||
try:
|
||||
with app.app_context():
|
||||
load_problems_from_json(json_path)
|
||||
time.sleep(interval_hours * 3600)
|
||||
except Exception as e:
|
||||
print(f"Error in problem reload loop: {e}")
|
||||
time.sleep(60) # Wait 1 minute before retrying
|
||||
|
||||
t = threading.Thread(target=reload_loop, daemon=True)
|
||||
t.start()
|
||||
|
||||
def run_code_against_tests(user_code, test_code, timeout=10):
|
||||
"""
|
||||
Execute user code against test code with proper error handling.
|
||||
|
||||
Args:
|
||||
user_code: The user's solution code
|
||||
test_code: The test code to validate the solution
|
||||
timeout: Maximum execution time in seconds
|
||||
|
||||
Returns:
|
||||
dict: Result with passed, output, runtime, and error fields
|
||||
"""
|
||||
if not user_code or not user_code.strip():
|
||||
return {
|
||||
'passed': False,
|
||||
'output': '',
|
||||
'runtime': 0,
|
||||
'error': 'No code provided'
|
||||
}
|
||||
|
||||
if not test_code or not test_code.strip():
|
||||
return {
|
||||
'passed': False,
|
||||
'output': '',
|
||||
'runtime': 0,
|
||||
'error': 'No test code available'
|
||||
}
|
||||
|
||||
start_time = time.perf_counter()
|
||||
output = ''
|
||||
error = None
|
||||
passed = False
|
||||
temp_file = None
|
||||
|
||||
try:
|
||||
# Check if unittest is used in test_code
|
||||
if 'unittest' in test_code:
|
||||
# Create temporary file with user code + test code
|
||||
with tempfile.NamedTemporaryFile('w+', suffix='.py', delete=False, encoding='utf-8') as f:
|
||||
# Combine user code and test code
|
||||
combined_code = f"{user_code}\n\n{test_code}"
|
||||
f.write(combined_code)
|
||||
f.flush()
|
||||
temp_file = f.name
|
||||
|
||||
try:
|
||||
# Run the file as a subprocess with timeout
|
||||
proc = subprocess.run(
|
||||
[sys.executable, temp_file],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=timeout,
|
||||
encoding='utf-8'
|
||||
)
|
||||
|
||||
output = proc.stdout
|
||||
if proc.stderr:
|
||||
output += f"\nSTDERR:\n{proc.stderr}"
|
||||
|
||||
passed = proc.returncode == 0
|
||||
if not passed:
|
||||
error = f"Tests failed. Return code: {proc.returncode}\n{output}"
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
passed = False
|
||||
error = f"Code execution timed out after {timeout} seconds"
|
||||
output = "Execution timed out"
|
||||
|
||||
else:
|
||||
# Direct execution approach for simple assert-based tests
|
||||
local_ns = {}
|
||||
|
||||
# Capture stdout
|
||||
old_stdout = sys.stdout
|
||||
captured_output = io.StringIO()
|
||||
sys.stdout = captured_output
|
||||
|
||||
try:
|
||||
# Execute user code first
|
||||
exec(user_code, {}, local_ns)
|
||||
|
||||
# Execute test code in the same namespace
|
||||
exec(test_code, local_ns, local_ns)
|
||||
|
||||
# If we get here without exceptions, tests passed
|
||||
passed = True
|
||||
|
||||
except AssertionError as e:
|
||||
passed = False
|
||||
error = f"Assertion failed: {str(e)}"
|
||||
|
||||
except Exception as e:
|
||||
passed = False
|
||||
error = f"Runtime error: {traceback.format_exc()}"
|
||||
|
||||
finally:
|
||||
output = captured_output.getvalue()
|
||||
sys.stdout = old_stdout
|
||||
|
||||
except Exception as e:
|
||||
passed = False
|
||||
error = f"Execution error: {traceback.format_exc()}"
|
||||
|
||||
finally:
|
||||
# Clean up temporary file
|
||||
if temp_file and os.path.exists(temp_file):
|
||||
try:
|
||||
os.unlink(temp_file)
|
||||
except Exception as e:
|
||||
print(f"Warning: Could not delete temp file {temp_file}: {e}")
|
||||
|
||||
runtime = time.perf_counter() - start_time
|
||||
|
||||
result = {
|
||||
'passed': passed,
|
||||
'output': output.strip() if output else '',
|
||||
'runtime': runtime,
|
||||
'error': error if not passed else None
|
||||
}
|
||||
|
||||
print(f"Test execution result: passed={passed}, runtime={runtime:.3f}s")
|
||||
if error:
|
||||
print(f"Error: {error}")
|
||||
|
||||
return result
|
||||
Reference in New Issue
Block a user