Address PR review comments

Author: bliu8

backend/games/generator.py

@@ -10,30 +10,29 @@
 if not zip_file_path.exists():
     raise FileNotFoundError(f"words.txt.zip not found at {zip_file_path}")
 
-with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
-    try:
-        with zip_ref.open("words.txt") as file:
-            ws = [line.decode("utf-8").strip() for line in file if line.strip()]
-    except KeyError as ex:
-        raise FileNotFoundError(f"words.txt is not in {zip_file_path}") from ex
-
-MIN_LEN, MAX_LEN = 3, 8
+MAX_LEN = 8
 MIN_TOTAL_WORDS = 175
 
 WORD_SET = set()
 PREFIX_SET = set()
 SIX_LETTER_WORDS = []
 
-for w in ws:
-    w = w.lower()
-    if not w.isalpha():
-        continue
-    if len(w) == 6:
-        SIX_LETTER_WORDS.append(w)
-    if MIN_LEN <= len(w) <= MAX_LEN:
-        WORD_SET.add(w)
-        for i in range(1, len(w) + 1):
-            PREFIX_SET.add(w[:i])
+with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
+    try:
+        with zip_ref.open("words.txt") as file:
+            for line in file:
+                if line.strip():
+                    w = line.decode("utf-8").strip().lower()
+                    if not w.isalpha():
+                        continue
+                    if len(w) == 6:
+                        SIX_LETTER_WORDS.append(w)
+                    if len(w) <= MAX_LEN:
+                        WORD_SET.add(w)
+                        for i in range(1, len(w) + 1):
+                            PREFIX_SET.add(w[:i])
+    except KeyError as ex:
+        raise FileNotFoundError(f"words.txt is not in {zip_file_path}") from ex
 
 
 def neighbors(n, x, y):
@@ -69,35 +68,31 @@ def generate_game():
     return game, seed_word
 
 
-def solve_game(game, min_len=MIN_LEN, max_len=MAX_LEN):
+def solve_game(game, min_len=3, max_len=MAX_LEN):
     n = len(game)
     dirs = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
 
     found = set()
-    visited = [[False] * n for _ in range(n)]
-
-    def dfs(r, c, s):
-        s += game[r][c]
-        if s not in PREFIX_SET:
-            return
-        if len(s) >= min_len and s in WORD_SET:
-            found.add(s)
-        if len(s) == max_len:
-            return
-
-        visited[r][c] = True
-        for dr, dc in dirs:
-            rr, cc = r + dr, c + dc
-            if 0 <= rr < n and 0 <= cc < n and not visited[rr][cc]:
-                dfs(rr, cc, s)
-        visited[r][c] = False
 
     for r in range(n):
         for c in range(n):
-            dfs(r, c, "")
-
-    results = sorted(found, key=lambda w: (-len(w), w))
-    return results
+            stack = [(r, c, "", frozenset())]
+            while stack:
+                cr, cc, s, vis = stack.pop()
+                s = s + game[cr][cc]
+                if s not in PREFIX_SET:
+                    continue
+                if len(s) >= min_len and s in WORD_SET:
+                    found.add(s)
+                if len(s) == max_len:
+                    continue
+                vis = vis | {(cr, cc)}
+                for dr, dc in dirs:
+                    rr, nc = cr + dr, cc + dc
+                    if 0 <= rr < n and 0 <= nc < n and (rr, nc) not in vis:
+                        stack.append((rr, nc, s, vis))
+
+    return sorted(found, key=lambda w: (-len(w), w))
 
 
 def generate_good_game(min_total_words=MIN_TOTAL_WORDS):

backend/games/management/commands/generate_game.py

@@ -23,7 +23,7 @@ def handle(self, *args, **kwargs):
                     "board": game,
                     "possible_words": sols,
                     "seed": seed,
-                    "freqs": word_freqs,
+                    "word_length_freq": word_freqs,
                 },
             )
 

backend/games/migrations/0003_alter_leaderboardentry_options_and_more.py

@@ -0,0 +1,27 @@
+# Generated by Django 5.0.2 on 2026-03-30 02:51
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("games", "0002_game_freqs"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="leaderboardentry",
+            options={"ordering": ["-score"]},
+        ),
+        migrations.RenameField(
+            model_name="game",
+            old_name="freqs",
+            new_name="word_length_freq",
+        ),
+        migrations.RenameField(
+            model_name="leaderboardentry",
+            old_name="words_found",
+            new_name="num_words_found",
+        ),
+    ]

backend/games/models.py

@@ -11,7 +11,7 @@ class Game(models.Model):
     board = models.JSONField()
     possible_words = models.JSONField()
     seed = models.CharField(max_length=32)
-    freqs = models.JSONField(default=dict)
+    word_length_freq = models.JSONField(default=dict)
 
     def __str__(self):
         return str(self.date)
@@ -26,12 +26,12 @@ class LeaderboardEntry(models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="word_hunt_scores")
 
     score = models.PositiveIntegerField(db_index=True)
-    words_found = models.PositiveIntegerField()
+    num_words_found = models.PositiveIntegerField()
 
     submitted_at = models.DateTimeField(auto_now_add=True)
 
     class Meta:
         constraints = [
             models.UniqueConstraint(fields=["game", "user"], name="unique_entry_per_user_per_game")
         ]
-        ordering = ["-score", "words_found", "submitted_at"]
+        ordering = ["-score"]

backend/games/serializers.py

@@ -20,4 +20,4 @@ class LeaderboardEntrySerializer(serializers.ModelSerializer):
 
     class Meta:
         model = LeaderboardEntry
-        fields = ["username", "score", "words_found", "submitted_at"]
+        fields = ["username", "score", "num_words_found", "submitted_at"]

backend/games/urls.py

@@ -1,18 +1,15 @@
 from django.urls import path
 
-from games.views import (
-    GameByDateView,
-    LeaderboardByDateView,
-    SubmitScoreView,
-    TodayGameView,
-    ValidateGameLogView,
-)
+from games.views import GameByDateView, LeaderboardByDateView, SubmitScoreView, TodayGameView
 
 
 urlpatterns = [
-    path("today/", TodayGameView.as_view(), name="game-today"),
-    path("<date>/", GameByDateView.as_view(), name="game-by-date"),
-    path("<date>/leaderboard/", LeaderboardByDateView.as_view(), name="game-leaderboard-by-date"),
-    path("<date>/submit/", SubmitScoreView.as_view(), name="submit-score"),
-    path("<date>/validate/", ValidateGameLogView.as_view(), name="validate-game-log"),
+    path("word-hunt/today/", TodayGameView.as_view(), name="word-hunt-today"),
+    path("word-hunt/<date>/", GameByDateView.as_view(), name="word-hunt-by-date"),
+    path(
+        "word-hunt/<date>/leaderboard/",
+        LeaderboardByDateView.as_view(),
+        name="word-hunt-leaderboard-by-date",
+    ),
+    path("word-hunt/<date>/submit/", SubmitScoreView.as_view(), name="word-hunt-submit-score"),
 ]

backend/games/views.py

@@ -6,7 +6,6 @@
 
 from games.models import Game, LeaderboardEntry
 from games.serializers import GameSerializer, LeaderboardEntrySerializer
-from games.validators import validate_words_for_game
 from pennmobile.analytics import LabsAnalytics
 
 
@@ -63,57 +62,39 @@ def get(self, request, date):
 )
 class SubmitScoreView(APIView):
     """
-    POST: submits the authenticated user's score for a specific date
+    POST: validates submitted words, computes score, and saves leaderboard entry
     """
 
     permission_classes = [IsAuthenticated]
 
     def post(self, request, date):
         game = get_object_or_404(Game, date=date)
-        score = request.data.get("score")
-        words_found = request.data.get("words_found")
-
-        if score is None or words_found is None:
-            return Response({"error": "score and words_found are required."}, status=400)
-
-        if (
-            not isinstance(score, int)
-            or not isinstance(words_found, int)
-            or score < 0
-            or words_found < 0
-        ):
+        submitted_words = request.data.get("words")
+
+        if not isinstance(submitted_words, list):
+            return Response({"error": "words must be a list."}, status=400)
+
+        normalized = [w.lower().strip() for w in submitted_words]
+
+        if len(normalized) != len(set(normalized)):
+            return Response({"error": "Duplicate words submitted."}, status=400)
+
+        legal_words = set(game.possible_words)
+        invalid = [w for w in normalized if w not in legal_words]
+        if invalid:
             return Response(
-                {"error": "score and words_found must be non-negative integers."}, status=400
+                {"error": "Invalid words submitted.", "invalid_words": invalid}, status=400
             )
 
         if LeaderboardEntry.objects.filter(game=game, user=request.user).exists():
             return Response({"error": "Score already submitted for this game."}, status=400)
 
+        score = sum((len(w) - 2) ** 2 * 100 for w in normalized)
+
         entry = LeaderboardEntry.objects.create(
             game=game,
             user=request.user,
             score=score,
-            words_found=words_found,
+            num_words_found=len(normalized),
         )
         return Response(LeaderboardEntrySerializer(entry).data, status=201)
-
-
-@LabsAnalytics.record_apiview(
-    ViewEntry(name="validate-game-log"),
-)
-class ValidateGameLogView(APIView):
-    """
-    POST: returns whether the words chosen are valid
-    """
-
-    permission_classes = [IsAuthenticated]
-
-    def post(self, request, date):
-        game = get_object_or_404(Game, date=date)
-        submitted_words = request.data.get("words", [])
-
-        result = validate_words_for_game(game, submitted_words)
-        if not result["valid"]:
-            return Response(result, status=400)
-
-        return Response({"valid": True}, status=200)

backend/test_games.py

@@ -0,0 +1,98 @@
+import json
+import os
+
+import django
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pennmobile.settings")
+django.setup()
+
+from django.contrib.auth import get_user_model  # noqa: E402
+from rest_framework.test import APIClient  # noqa: E402
+
+from games.generator import generate_good_game  # noqa: E402
+from games.models import Game, LeaderboardEntry  # noqa: E402
+
+
+User = get_user_model()
+client = APIClient()
+
+print("\n" + "=" * 50)
+
+# TASK 1 ----------------------------------------------------------------------
+print("--- Testing Task 1: Generate Games & Store in DB ---")
+try:
+    game_board, seed, sols = generate_good_game(
+        min_total_words=50
+    )  # Using a smaller number so it tests quickly
+    print("✅ Game generation script successful! Seed word generated:", seed)
+
+    game = Game.get_today()
+    if game:
+        print(f"✅ Django DB Game model successfully loaded for {game.date}.")
+        print("   Board format:", type(game.board), "->", game.board[0], "...")
+    else:
+        print("❌ No game for today found. Ensure you ran 'python manage.py generate_game'")
+except Exception as e:
+    print("❌ Generation/Model script failed:", str(e))
+
+
+# TASK 2 ----------------------------------------------------------------------
+print("\n--- Testing Task 2: Models for storing game results (User+Day) ---")
+user, _ = User.objects.get_or_create(username="testuser")
+dummy_user, _ = User.objects.get_or_create(username="dummyuser2")
+
+try:
+    entry, created = LeaderboardEntry.objects.get_or_create(
+        game=game, user=dummy_user, defaults={"score": 100, "num_words_found": 5}
+    )
+    print(
+        f"✅ LeaderboardEntry model works for {dummy_user.username}. "
+        f"Associated with Game {game.date}."
+    )
+    print(f"✅ Relational lookup successful: game.scores.count() = {game.scores.count()}")
+
+except Exception as e:
+    print("❌ Leaderboard model creation failed:", str(e))
+
+
+client.force_authenticate(user=user)
+
+# TASK 3 ----------------------------------------------------------------------
+print("\n--- Testing Task 3: Fetch Game Route ---")
+response = client.get("/games/word-hunt/today/", format="json")
+print(f"✅ Route Status Code: {response.status_code}")
+print("✅ JSON Data Payload Extract:")
+print(json.dumps(response.data, indent=2)[:200] + "...\n")
+
+
+# TASK 4 ----------------------------------------------------------------------
+print("--- Testing Task 4: Submit Score Route (valid words) ---")
+valid_words = game.possible_words[:3] if game and game.possible_words else []
+data = {"words": valid_words}
+response = client.post(f"/games/word-hunt/{game.date}/submit/", data, format="json")
+print(f"✅ Route Status Code: {response.status_code}")
+print("✅ Submit Route Response:")
+print(json.dumps(response.data, indent=2) + "\n")
+
+
+# TASK 5 ----------------------------------------------------------------------
+print("--- Testing Task 5: Submit Score Route (invalid words) ---")
+data = {"words": [valid_words[0] if valid_words else "cat", "notarealword123"]}
+response2_user, _ = User.objects.get_or_create(username="testuser2")
+client2 = APIClient()
+client2.force_authenticate(user=response2_user)
+response = client2.post(f"/games/word-hunt/{game.date}/submit/", data, format="json")
+print(f"✅ Route Status Code: {response.status_code}")
+print("✅ Validation Error Response:")
+print(json.dumps(response.data, indent=2) + "\n")
+
+
+# TASK 6 ----------------------------------------------------------------------
+print("--- Testing Task 6: Leaderboard Route ---")
+response = client.get(f"/games/word-hunt/{game.date}/leaderboard/", format="json")
+print(f"✅ Route Status Code: {response.status_code}")
+print("✅ Leaderboard JSON Output (Ranked):")
+print(json.dumps(response.data, indent=2))
+
+print("=" * 50 + "\n")

backend/tests/games/test_commands.py

@@ -52,7 +52,7 @@ def test_computes_word_freqs_by_length(self):
         expected = {"3": 0, "4": 0, "5": 0, "6": 0, "7": 0, "8": 0}
         for w in MOCK_SOLS:
             expected[str(len(w))] += 1
-        self.assertEqual(expected, game.freqs)
+        self.assertEqual(expected, game.word_length_freq)
 
     @mock.patch(
         "games.management.commands.generate_game.generate_good_game", mock_generate_good_game