Address ngc92 feedback: unify queries and return all runs per submission

- Unified SQL queries in get_user_submissions() by building WHERE clause
  conditionally instead of duplicating the entire query
- Changed response structure to return all runs per submission as a list
  with (gpu_type, score) tuples instead of using DISTINCT ON for one run
- Simplified runs serialization in get_user_submission endpoint using
  dict comprehension with explicit field selection
- Added test for multiple runs per submission

Author: msaroufim

src/kernelbot/api/main.py

@@ -777,6 +777,8 @@ async def get_user_submission(
             if str(submission["user_id"]) != str(user_info["user_id"]):
                 raise HTTPException(status_code=403, detail="Not authorized to view this submission")
 
+            # RunItem is a TypedDict (already a dict), select fields to expose
+            run_fields = ("start_time", "end_time", "mode", "secret", "runner", "score", "passed")
             return {
                 "id": submission["submission_id"],
                 "leaderboard_id": submission["leaderboard_id"],
@@ -786,18 +788,7 @@ async def get_user_submission(
                 "submission_time": submission["submission_time"],
                 "done": submission["done"],
                 "code": submission["code"],
-                "runs": [
-                    {
-                        "start_time": r["start_time"],
-                        "end_time": r["end_time"],
-                        "mode": r["mode"],
-                        "secret": r["secret"],
-                        "runner": r["runner"],
-                        "score": r["score"],
-                        "passed": r["passed"],
-                    }
-                    for r in submission["runs"]
-                ],
+                "runs": [{k: r[k] for k in run_fields} for r in submission["runs"]],
             }
     except HTTPException:
         raise

src/libkernelbot/leaderboard_db.py

@@ -865,62 +865,66 @@ def get_user_submissions(
             offset: Offset for pagination
 
         Returns:
-            List of submission dictionaries with summary info
+            List of submission dictionaries with summary info and runs
         """
         # Validate and clamp inputs
         limit = max(1, min(limit, 100))
         offset = max(0, offset)
 
         try:
+            # Build query with conditional WHERE clause
+            where_clause = "WHERE s.user_id = %s"
+            params: list = [user_id]
+
             if leaderboard_name:
-                query = """
-                    SELECT DISTINCT ON (s.id)
-                        s.id,
-                        lb.name as leaderboard_name,
-                        s.file_name,
-                        s.submission_time,
-                        s.done,
-                        r.runner as gpu_type,
-                        r.score
-                    FROM leaderboard.submission s
-                    JOIN leaderboard.leaderboard lb ON s.leaderboard_id = lb.id
-                    LEFT JOIN leaderboard.runs r ON r.submission_id = s.id
-                        AND NOT r.secret AND r.passed
-                    WHERE s.user_id = %s AND lb.name = %s
-                    ORDER BY s.id, s.submission_time DESC
-                    LIMIT %s OFFSET %s
-                """
-                self.cursor.execute(query, (user_id, leaderboard_name, limit, offset))
-            else:
-                query = """
-                    SELECT DISTINCT ON (s.id)
-                        s.id,
-                        lb.name as leaderboard_name,
-                        s.file_name,
-                        s.submission_time,
-                        s.done,
-                        r.runner as gpu_type,
-                        r.score
-                    FROM leaderboard.submission s
-                    JOIN leaderboard.leaderboard lb ON s.leaderboard_id = lb.id
-                    LEFT JOIN leaderboard.runs r ON r.submission_id = s.id
-                        AND NOT r.secret AND r.passed
-                    WHERE s.user_id = %s
-                    ORDER BY s.id, s.submission_time DESC
-                    LIMIT %s OFFSET %s
-                """
-                self.cursor.execute(query, (user_id, limit, offset))
+                where_clause += " AND lb.name = %s"
+                params.append(leaderboard_name)
+
+            # First, get distinct submissions
+            submission_query = f"""
+                SELECT s.id, lb.name as leaderboard_name, s.file_name,
+                       s.submission_time, s.done
+                FROM leaderboard.submission s
+                JOIN leaderboard.leaderboard lb ON s.leaderboard_id = lb.id
+                {where_clause}
+                ORDER BY s.submission_time DESC
+                LIMIT %s OFFSET %s
+            """
+            self.cursor.execute(submission_query, params + [limit, offset])
+            submissions = self.cursor.fetchall()
 
+            if not submissions:
+                return []
+
+            # Get all runs for these submissions
+            submission_ids = [row[0] for row in submissions]
+            runs_query = """
+                SELECT submission_id, runner as gpu_type, score
+                FROM leaderboard.runs
+                WHERE submission_id = ANY(%s) AND NOT secret AND passed
+            """
+            self.cursor.execute(runs_query, (submission_ids,))
+            runs_by_submission: dict = {}
+            for run_row in self.cursor.fetchall():
+                sub_id = run_row[0]
+                if sub_id not in runs_by_submission:
+                    runs_by_submission[sub_id] = []
+                runs_by_submission[sub_id].append({
+                    "gpu_type": run_row[1],
+                    "score": run_row[2],
+                })
+
+            # Build result with runs grouped by submission
             results = []
-            for row in self.cursor.fetchall():
+            for row in submissions:
+                sub_id = row[0]
                 results.append({
-                    "id": row[0],
+                    "id": sub_id,
                     "leaderboard_name": row[1],
                     "file_name": row[2],
                     "submission_time": row[3],
                     "done": row[4],
-                    "gpu_type": row[5],
-                    "score": row[6],
+                    "runs": runs_by_submission.get(sub_id, []),
                 })
             return results
         except psycopg2.Error as e:

tests/test_leaderboard_db.py

@@ -738,3 +738,40 @@ def test_get_user_submissions_pagination(database, submit_leaderboard):
         assert len(result_offset) == 2
         assert result_offset[0]["id"] == result_all[2]["id"]
 
+
+def test_get_user_submissions_with_multiple_runs(database, submit_leaderboard):
+    """Test get_user_submissions returns all runs per submission"""
+    with database as db:
+        # Create a submission
+        sub1 = db.create_submission(
+            "submit-leaderboard",
+            "multi_run.py",
+            5,
+            "code",
+            datetime.datetime.now(tz=datetime.timezone.utc),
+            user_name="user5",
+        )
+
+        # Add multiple runs on different GPUs
+        _create_submission_run(db, sub1, runner="A100", score=1.5, secret=False)
+        _create_submission_run(db, sub1, runner="H100", score=2.0, secret=False)
+        db.mark_submission_done(sub1)
+
+        # Get submissions
+        result = db.get_user_submissions(user_id="5")
+        assert len(result) == 1
+
+        # Verify runs list contains both runs
+        submission = result[0]
+        assert "runs" in submission
+        assert len(submission["runs"]) == 2
+
+        # Verify run data
+        gpu_types = {r["gpu_type"] for r in submission["runs"]}
+        assert "A100" in gpu_types
+        assert "H100" in gpu_types
+
+        scores = {r["score"] for r in submission["runs"]}
+        assert 1.5 in scores
+        assert 2.0 in scores
+