[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

othello/apps/games/admin.py

@@ -1,6 +1,6 @@
 from django.contrib import admin
 
-from .models import Game, GameError, Submission, Match
+from .models import Game, GameError, Match, Submission
 
 
 class GameErrorAdmin(admin.TabularInline):
@@ -17,6 +17,7 @@ class GameAdmin(admin.ModelAdmin):
 class SubmissionAdmin(admin.ModelAdmin):
     readonly_fields = ("id",)
 
+
 class MatchAdmin(admin.ModelAdmin):
     readonly_fields = ("id",)
 

othello/apps/games/consumers.py

@@ -35,7 +35,6 @@ def connect(self) -> None:
             self.game.channels_group_name, self.channel_name
         )
 
-        # Send initial game state
         self.update_game()
 
     def disconnect(self, code: int) -> None:
@@ -87,9 +86,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
     def connect(self) -> None:
         self.connected = True
         self.accept()
-        async_to_sync(self.channel_layer.group_add)(
-            "matches", self.channel_name
-        )
+        async_to_sync(self.channel_layer.group_add)("matches", self.channel_name)
 
     def disconnect(self, code: int) -> None:
         self.connected = False
@@ -101,19 +98,21 @@ def send_match_update(self, object_id: int) -> None:
         if self.connected:
             match = Match.objects.get(id=object_id)
             score = "-"
-            if match.status == 'completed':
+            if match.status == "completed":
                 score = f"{match.player1_wins}-{match.ties}-{match.player2_wins}"
-            self.send_json({
-                'type': 'match_update',
-                'match_id': match.id,
-                'status': match.status,
-                'player1': match.player1.get_game_name(),
-                'player2': match.player2.get_game_name(),
-                'num_games': match.num_games,
-                'score': score,
-                'created_at': match.created_at.isoformat(),
-            })
-            
+            self.send_json(
+                {
+                    "type": "match_update",
+                    "match_id": match.id,
+                    "status": match.status,
+                    "player1": match.player1.get_game_name(),
+                    "player2": match.player2.get_game_name(),
+                    "num_games": match.num_games,
+                    "score": score,
+                    "created_at": match.created_at.isoformat(),
+                }
+            )
+
 
 class GamePlayingConsumer(GameConsumer):
     def connect(self) -> None:

othello/apps/games/forms.py

@@ -7,7 +7,7 @@
 from django.core.exceptions import ValidationError
 
 from ...sandboxing import import_strategy_sandboxed
-from .models import Match, Submission
+from .models import Submission
 
 
 class SubmissionForm(forms.ModelForm):
@@ -77,12 +77,12 @@ class Meta:
 
 class MatchForm(forms.Form):
     opponent = forms.ModelChoiceField(label="Opponent:", queryset=Submission.objects.none())
-    num_games = forms.IntegerField(
-        label="Number of Games:", initial=3, min_value=1, max_value=10
-    )
+    num_games = forms.IntegerField(label="Number of Games:", initial=3, min_value=1, max_value=10)
 
     def __init__(self, user, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        opponents = Submission.objects.latest().exclude(user=user).exclude(user__username="Yourself")
+        opponents = (
+            Submission.objects.latest().exclude(user=user).exclude(user__username="Yourself")
+        )
         self.fields["opponent"].queryset = opponents
-        self.fields["opponent"].label_from_instance = Submission.get_game_name
+        self.fields["opponent"].label_from_instance = Submission.get_game_name

othello/apps/games/models.py

@@ -37,7 +37,8 @@ def latest(self, onesub=False, **kwargs: Any) -> "models.query.QuerySet[Submissi
             .distinct("user")
             .order_by("user", "-tournament_win_year", "-created_at")
         )
-    
+
+
 class Submission(models.Model):
     objects: Any = SubmissionQuerySet.as_manager()
 
@@ -58,7 +59,7 @@ class Meta:
                 check=models.Q(user__isnull=False) | models.Q(name__isnull=False),
             )
         ]
-        get_latest_by = 'created_at'
+        get_latest_by = "created_at"
 
     def get_user_name(self) -> str:
         return self.user.short_name
@@ -98,31 +99,39 @@ def wins_for_user(self, submission: Submission) -> int:
             )
             .count()
         )
-    
+
+
 class MatchQuerySet(models.QuerySet):
     def running(self) -> "models.query.QuerySet[Match]":
-        return self.filter(status='running')
-
+        return self.filter(status="running")
 
 
 class Match(models.Model):
     STATUS_CHOICES = (
-        ('pending', 'Pending'),
-        ('running', 'Running'),
-        ('completed', 'Completed'),
+        ("pending", "Pending"),
+        ("running", "Running"),
+        ("completed", "Completed"),
     )
 
     objects: Any = MatchQuerySet.as_manager()
 
-    player1 = models.ForeignKey(Submission, on_delete=models.CASCADE, related_name='matches_as_player1')
-    player2 = models.ForeignKey(Submission, on_delete=models.CASCADE, related_name='matches_as_player2')
+    player1 = models.ForeignKey(
+        Submission, on_delete=models.CASCADE, related_name="matches_as_player1"
+    )
+    player2 = models.ForeignKey(
+        Submission, on_delete=models.CASCADE, related_name="matches_as_player2"
+    )
     num_games = models.IntegerField(default=5)
-    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
+    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default="pending")
     created_at = models.DateTimeField(auto_now_add=True)
 
     # Results
-    winner = models.ForeignKey(Submission, null=True, blank=True, on_delete=models.CASCADE, related_name='won_matches')
-    loser = models.ForeignKey(Submission, null=True, blank=True, on_delete=models.CASCADE, related_name='lost_matches')
+    winner = models.ForeignKey(
+        Submission, null=True, blank=True, on_delete=models.CASCADE, related_name="won_matches"
+    )
+    loser = models.ForeignKey(
+        Submission, null=True, blank=True, on_delete=models.CASCADE, related_name="lost_matches"
+    )
     is_tie = models.BooleanField(default=False)
     player1_wins = models.IntegerField(default=0)
     player2_wins = models.IntegerField(default=0)
@@ -169,7 +178,9 @@ def calculate_results(self) -> None:
             self.winner = None
             self.loser = None
 
-        self.save(update_fields=['player1_wins', 'player2_wins', 'ties', 'winner', 'loser', 'is_tie'])
+        self.save(
+            update_fields=["player1_wins", "player2_wins", "ties", "winner", "loser", "is_tie"]
+        )
 
     def __str__(self) -> str:
         return f"{self.player1.get_game_name()} vs {self.player2.get_game_name()} ({self.num_games} games)"
@@ -187,7 +198,9 @@ class Game(models.Model):
 
     black = models.ForeignKey(Submission, on_delete=models.CASCADE, related_name="black")
     white = models.ForeignKey(Submission, on_delete=models.CASCADE, related_name="white")
-    match = models.ForeignKey(Match, null=True, blank=True, on_delete=models.CASCADE, related_name="games")
+    match = models.ForeignKey(
+        Match, null=True, blank=True, on_delete=models.CASCADE, related_name="games"
+    )
     time_limit = models.IntegerField(default=5, validators=[validate_game_time_limit])
     runoff = models.BooleanField(default=False)
 
@@ -250,4 +263,4 @@ class GameError(GameObject):
 
 class GameLog(GameObject):
     game = models.ForeignKey(Game, on_delete=models.CASCADE, related_name="logs")
-    message = models.TextField(default="")
+    message = models.TextField(default="")

othello/apps/games/tasks.py

@@ -37,7 +37,7 @@ def delete_game(game: Game) -> None:
         game.delete()
 
 
-@shared_task(queue='game_queue')
+@shared_task(queue="game_queue")
 def run_game(game_id: int) -> str | None:
     try:
         game = Game.objects.get(id=game_id)
@@ -189,7 +189,7 @@ def run_game(game_id: int) -> str | None:
 
     if game.match and not game.match.games.filter(playing=True).exists():
         task_logger.info(f"MATCH {game.match.id} OVER")
-        game.match.status = 'completed'
+        game.match.status = "completed"
         game.match.save(update_fields=["status"])
         game.match.calculate_results()
         async_to_sync(get_channel_layer().group_send)(
@@ -217,8 +217,8 @@ def run_match(match_id: int) -> str | None:
         logger.error(f"Trying to run nonexistent match ({match_id})")
         return "match not found"
 
-    match.status = 'running'
-    match.save(update_fields=['status'])
+    match.status = "running"
+    match.save(update_fields=["status"])
     send_through_match_channel(match, "match.update", match_id)
 
     games = []
@@ -244,4 +244,4 @@ def send_through_match_channel(match: Match, event_type: str, object_id: int) ->
     task_logger.debug(f"sending {event_type}")
     async_to_sync(get_channel_layer().group_send)(
         match.channels_group_name, {"type": event_type, "object_id": object_id}
-    )
+    )

othello/apps/games/views.py

@@ -11,8 +11,8 @@
 
 from .forms import DownloadSubmissionForm, GameForm, MatchForm, SubmissionForm
 from .models import Game, Match, Submission
-from .utils import serialize_game_info
 from .tasks import run_match
+from .utils import serialize_game_info
 
 logger = logging.getLogger("othello")
 
@@ -111,6 +111,7 @@ def play(request: HttpRequest) -> HttpResponse:
     initial = json.loads(request.session.get("form-data", "{}"))
     return render(request, "games/design.html", {"form": GameForm(initial=initial)})
 
+
 @login_required
 def request_match(request: HttpRequest) -> HttpResponse:
     if request.method == "POST":
@@ -119,23 +120,32 @@ def request_match(request: HttpRequest) -> HttpResponse:
             cd = form.cleaned_data
 
             one_hour_ago = timezone.now() - timezone.timedelta(hours=1)
-            recent_games = Match.objects.filter(
-                models.Q(player1__user=request.user) | models.Q(player2__user=request.user),
-                created_at__gte=one_hour_ago
-            ).aggregate(total_games=models.Sum('num_games'))['total_games'] or 0
-            if recent_games + cd['num_games'] > 100:
-                messages.error(request, "You have exceeded the limit of 100 games per hour.", extra_tags="danger")
+            recent_games = (
+                Match.objects.filter(
+                    models.Q(player1__user=request.user) | models.Q(player2__user=request.user),
+                    created_at__gte=one_hour_ago,
+                ).aggregate(total_games=models.Sum("num_games"))["total_games"]
+                or 0
+            )
+            if recent_games + cd["num_games"] > 100:
+                messages.error(
+                    request,
+                    "You have exceeded the limit of 100 games per hour.",
+                    extra_tags="danger",
+                )
                 return redirect("games:request_match")
 
             user_submission = Submission.objects.filter(user=request.user).latest(onesub=True)
             if not user_submission:
-                messages.error(request, f"Could not request match because you do not have a submission")
+                messages.error(
+                    request, "Could not request match because you do not have a submission"
+                )
                 return redirect("games:queue")
-            
+
             match = Match.objects.create(
                 player1=user_submission,
-                player2=cd['opponent'],
-                num_games=cd['num_games'],
+                player2=cd["opponent"],
+                num_games=cd["num_games"],
             )
             run_match.delay(match.id)
             messages.success(request, f"Match requested against {cd['opponent'].get_game_name()}.")
@@ -151,12 +161,13 @@ def request_match(request: HttpRequest) -> HttpResponse:
 
 @login_required
 def queue(request: HttpRequest) -> HttpResponse:
-    matches = Match.objects.all().order_by('-created_at')
+    matches = Match.objects.all().order_by("-created_at")
     paginator = Paginator(matches, 10)  # 10 per page
-    page_number = request.GET.get('page')
+    page_number = request.GET.get("page")
     page_obj = paginator.get_page(page_number)
     return render(request, "games/queue.html", {"page_obj": page_obj})
 
+
 def watch(request: HttpRequest, game_id: int | None = None) -> HttpResponse:
     if game_id is not None:
         return render(
@@ -177,23 +188,27 @@ def replay(request: HttpRequest) -> HttpResponse:
 @login_required
 def match_replay(request: HttpRequest, match_id: int) -> HttpResponse:
     match = get_object_or_404(Match, id=match_id)
-    games = list(match.games.order_by('created_at'))
-    selected_game_id = request.GET.get('game_id')
+    games = list(match.games.order_by("created_at"))
+    selected_game_id = request.GET.get("game_id")
     if selected_game_id:
         selected_game = get_object_or_404(Game, id=selected_game_id, match=match)
     elif games:
         selected_game = games[0]
     else:
         selected_game = None
-    
+
     game_data = serialize_game_info(selected_game) if selected_game else None
-    
-    return render(request, 'games/match_replay.html', {
-        'match': match,
-        'games': games,
-        'selected_game': selected_game,
-        'game_data': game_data,
-    })
+
+    return render(
+        request,
+        "games/match_replay.html",
+        {
+            "match": match,
+            "games": games,
+            "selected_game": selected_game,
+            "game_data": game_data,
+        },
+    )
 
 
 def about(request: HttpRequest) -> HttpResponse:

othello/settings/__init__.py

@@ -20,7 +20,7 @@
     "default": {
         "BACKEND": "channels_redis.core.RedisChannelLayer",
         "CONFIG": {
-            "hosts": [("othello_redis", 6379)],
+            "hosts": [("localhost", 6379)],
             "capacity": 1500,
             "expiry": 2,
         },
@@ -144,7 +144,7 @@
 
 # Celery
 CELERY_RESULT_BACKEND = "django-db"
-CELERY_BROKER_URL = "redis://othello_redis:6379/1"
+CELERY_BROKER_URL = "redis://localhost:6379/1"
 CELERY_TIMEZONE = "America/New_York"
 CELERY_BEAT_SCHEDULE = {
     "delete-old-games": {

othello/static/js/games/match_replay.js

@@ -20,7 +20,6 @@ function clearErrors(){
     $("pre.err_log").remove();
 }
 
-// Convert Django game data to replay format
 function convertGameDataToReplay(gameData) {
     if (!gameData || !gameData.moves) {
         return null;
@@ -32,11 +31,6 @@ function convertGameDataToReplay(gameData) {
         game: []
     };
 
-    // Standard Othello initial board
-    const initialBoard = '...........................ox......xo...........................';
-    let blackCount = (initialBoard.match(/x/g) || []).length;
-    let whiteCount = (initialBoard.match(/o/g) || []).length;
-    
     for (let i = gameData.moves.length - 1; i >= 0; i--) {
         let move = gameData.moves[i];
         let board = move.board;
@@ -115,6 +109,5 @@ window.onload = function () {
 
     $(document).on('mousemove', mouseOver);
 
-    // Start the match replay
     startMatchReplay();
 };