v2 to use tinydb for db.

app_utils.py

@@ -1,48 +1,24 @@
 import json
 import os
 import datetime
-import sqlite3
 from pathlib import Path
 from dotenv import load_dotenv
-from pymongo import MongoClient
-from pymongo.errors import ServerSelectionTimeoutError
-from bson import json_util
+from tinydb import TinyDB, Query
+from tinydb.storages import JSONStorage
+from tinydb.middlewares import CachingMiddleware
 import tempfile
 
 load_dotenv()
 SESSION_ID = os.getenv('SESSION_ID')
 print(f"Session ID: {SESSION_ID}")
-DB_URL = os.getenv('DB_URL')
+DB_PATH = 'submissions.json'
 ADMIN_PASSWD = os.getenv('ADMIN_PASSWD', 'default_password')
 SUBMISSIONS_DIR = 'submissions'
-# MongoDB connection setup remains the same
-try:
-    client = MongoClient(DB_URL, serverSelectionTimeoutMS=5000)
-    client.server_info()
-    USE_MONGO = True
-    db = client['COS501_app']
-    print("Successfully connected to MongoDB Atlas")
-except Exception as e:
-    print(f"MongoDB connection failed: {str(e)}")
-    USE_MONGO = False
-    sqlite_path = Path('submissions.db')
-    conn = sqlite3.connect(sqlite_path)
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS submissions (
-            session TEXT,
-            name TEXT,
-            email TEXT,
-            problem_id TEXT,
-            student_code TEXT,
-            hint_requested INTEGER,
-            timestamp TEXT,
-            PRIMARY KEY (session, name, email, problem_id)
-        )
-    ''')
-    conn.commit()
-    conn.close()
-    print("Falling back to SQLite database")
+
+# TinyDB connection setup
+db = TinyDB(DB_PATH, storage=CachingMiddleware(JSONStorage))
+submissions_table = db.table('submissions')
+print("Using TinyDB for data storage")
 
 def load_problems():
     problems = []
@@ -56,37 +32,18 @@ def load_problems():
     return problems
 
 def save_submission(session, name, email, problem_id, code, hint_requested):
-    timestamp = datetime.datetime.now()
-    if USE_MONGO:
-        collection = db.submissions
-        submission = {
-            'session': session,
-            'name': name,
-            'email': email,
-            'problem_id': problem_id,
-            'student_code': code,
-            'hint_requested': hint_requested,
-            'timestamp': timestamp
-        }
-        collection.update_one(
-            {'session': session, 'name': name, 'email': email, 'problem_id': problem_id},
-            {'$set': submission},
-            upsert=True
-        )
-    else:
-        conn = sqlite3.connect('submissions.db')
-        cursor = conn.cursor()
-        cursor.execute('''
-            INSERT OR REPLACE INTO submissions 
-            (session, name, email, problem_id, student_code, hint_requested, timestamp)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        ''', (
-            session, name, email, problem_id, code, 
-            1 if hint_requested else 0,
-            timestamp.isoformat()
-        ))
-        conn.commit()
-        conn.close()
+    timestamp = datetime.datetime.now().isoformat()
+    submission = {
+        'session': session,
+        'name': name,
+        'email': email,
+        'problem_id': problem_id,
+        'student_code': code,
+        'hint_requested': hint_requested,
+        'timestamp': timestamp
+    }
+    query = Query()
+    submissions_table.upsert(submission, (query.session == session) & (query.name == name) & (query.email == email) & (query.problem_id == problem_id))
 
 def save_all_submissions(name, email, codes_dict, hints_dict):
     try:
@@ -101,57 +58,19 @@ def check_password(password):
     return password == ADMIN_PASSWD
 
 def get_all_students():
-    if USE_MONGO:
-        return list(db.submissions.distinct("name"))
-    else:
-        conn = sqlite3.connect('submissions.db')
-        cursor = conn.cursor()
-        cursor.execute('SELECT DISTINCT name FROM submissions')
-        students = [row[0] for row in cursor.fetchall()]
-        conn.close()
-        return students
+    return list(set([submission['name'] for submission in submissions_table.all()]))
 
 def get_student_submissions(name):
-    if USE_MONGO:
-        submissions = list(db.submissions.find(
-            {"name": name}, 
-            {"_id": 0}
-        ).sort("timestamp", -1))
-        return submissions
-    else:
-        conn = sqlite3.connect('submissions.db')
-        cursor = conn.cursor()
-        cursor.execute('''
-            SELECT session, name, email, problem_id, student_code, hint_requested, timestamp 
-            FROM submissions WHERE name = ?
-            ORDER BY timestamp DESC
-        ''', (name,))
-        columns = ['session', 'name', 'email', 'problem_id', 'student_code', 'hint_requested', 'timestamp']
-        submissions = []
-        for row in cursor.fetchall():
-            submission = dict(zip(columns, row))
-            submission['hint_requested'] = bool(submission['hint_requested'])
-            submissions.append(submission)
-        conn.close()
-        return submissions
+    query = Query()
+    submissions = submissions_table.search(query.name == name)
+    submissions.sort(key=lambda x: x['timestamp'], reverse=True)
+    return submissions
 
 def export_submissions():
     try:
-        if USE_MONGO:
-            submissions = list(db.submissions.find({}, {"_id": 0}).sort("timestamp", -1))
-            data = json_util.dumps(submissions, indent=2)
-        else:
-            conn = sqlite3.connect('submissions.db')
-            cursor = conn.cursor()
-            cursor.execute('SELECT * FROM submissions ORDER BY timestamp DESC')
-            columns = ['session', 'name', 'email', 'problem_id', 'student_code', 'hint_requested', 'timestamp']
-            submissions = []
-            for row in cursor.fetchall():
-                submission = dict(zip(columns, row))
-                submission['hint_requested'] = bool(submission['hint_requested'])
-                submissions.append(submission)
-            conn.close()
-            data = json.dumps(submissions, indent=2)
+        submissions = submissions_table.all()
+        submissions.sort(key=lambda x: x['timestamp'], reverse=True)
+        data = json.dumps(submissions, indent=2)
         
         # Create a temporary file and write the data to it
         temp_file = tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.json')
@@ -163,17 +82,6 @@ def export_submissions():
         return None
 
 def refresh_submissions():
-    if USE_MONGO:
-        submissions = list(db.submissions.find({}, {"_id": 0}).sort("timestamp", -1))
-    else:
-        conn = sqlite3.connect('submissions.db')
-        cursor = conn.cursor()
-        cursor.execute('SELECT * FROM submissions ORDER BY timestamp DESC')
-        columns = ['session', 'name', 'email', 'problem_id', 'student_code', 'hint_requested', 'timestamp']
-        submissions = []
-        for row in cursor.fetchall():
-            submission = dict(zip(columns, row))
-            submission['hint_requested'] = bool(submission['hint_requested'])
-            submissions.append(submission)
-        conn.close()
+    submissions = submissions_table.all()
+    submissions.sort(key=lambda x: x['timestamp'], reverse=True)
     return submissions

requirements.txt

@@ -2,6 +2,7 @@ pymongo==4.10.1
 python-dotenv==1.0.1
 huggingface_hub==0.25.2
 gradio==4.44.1
+tinydb==4.8.2
 
 #google-auth==2.35.0
 #google-auth-httplib2==0.2.0

student_tab.py

@@ -87,18 +87,22 @@ def create_student_tab(problems):
         submit_all = gr.Button("Submit All")
         submit_status = gr.Markdown()
         
-        def submit_all_problems(name, email):
+        def submit_all_problems(values):
+            name, email, *code_values = values
             if not name or not email:
                 return "Please enter your name and email before submitting."
             
-            codes = {prob_id: code_box.value for prob_id, code_box in code_boxes.items()}
+            # Create dictionary of latest code values
+            codes = {prob_id: code for prob_id, code in zip(code_boxes.keys(), code_values)}
             hints = {prob_id: hint_state.value for prob_id, hint_state in hint_states.items()}
             
             return save_all_submissions(name, email, codes, hints)
         
+        # Create list of all inputs in correct order
+        all_inputs = [name, email] + list(code_boxes.values())
+        
         submit_all.click(
-            submit_all_problems,
-            [name, email],
-            submit_status
+            fn=lambda *args: submit_all_problems(args),
+            inputs=all_inputs,
+            outputs=submit_status
         )
-