feat: add strongest user rank (#57)

Author: emptybutton

src/ttt/application/user/common/ports/users.py

@@ -2,7 +2,9 @@
 from collections.abc import Sequence
 from typing import overload
 
+from ttt.entities.core.user.rank import UsersWithMaxRating
 from ttt.entities.core.user.user import User
+from ttt.entities.elo.rating import EloRating
 
 
 class Users(ABC):
@@ -43,3 +45,8 @@ async def users_with_ids(
     async def some_users_waiting_for_matchmaking_to_matchmake(
         self,
     ) -> list[User]: ...
+
+    @abstractmethod
+    async def max_rating_and_users_with_max_rating(
+        self,
+    ) -> tuple[EloRating, UsersWithMaxRating]: ...

src/ttt/application/user/game/matchmake.py

@@ -40,9 +40,14 @@ async def _result(self, tracking: Tracking) -> list[Game]:
             self.users.some_users_waiting_for_matchmaking_to_matchmake(),
             self._matchmaking_input(),
         )
+        max_rating, users_with_max_rating = (
+            await self.users.max_rating_and_users_with_max_rating()
+        )
 
         games = list[Game]()
-        matchmaking_ = matchmaking(users, input_, tracking)
+        matchmaking_ = matchmaking(
+            users, input_, max_rating, users_with_max_rating, tracking,
+        )
 
         with suppress(StopIteration):
             games.append(next(matchmaking_))

src/ttt/entities/core/user/matchmaking.py

@@ -3,8 +3,9 @@
 from uuid import UUID
 
 from ttt.entities.core.game.game import Game, start_game
-from ttt.entities.core.user.rank import are_ranks_adjacent
+from ttt.entities.core.user.rank import UsersWithMaxRating, are_ranks_adjacent
 from ttt.entities.core.user.user import User
+from ttt.entities.elo.rating import EloRating
 from ttt.entities.math.matrix import Matrix
 from ttt.entities.text.emoji import Emoji
 from ttt.entities.tools.combinations import Combinations
@@ -27,6 +28,8 @@ class UsersAreNotWaitingForMatchmakingError(Exception):
 def matchmaking(
     users: list[User],
     input_: MatchmakingInput,
+    max_rating: EloRating,
+    users_with_max_rating: UsersWithMaxRating,
     tracking: Tracking,
 ) -> Generator[Game, MatchmakingInput]:
     """
@@ -52,7 +55,7 @@ def matchmaking(
 
     combinations = Combinations(users)
     for user1, user2 in combinations:
-        if _is_game_allowed(user1, user2):
+        if _is_game_allowed(user1, user2, max_rating, users_with_max_rating):
             user1.dont_wait_for_matchmaking(tracking)
             user2.dont_wait_for_matchmaking(tracking)
             combinations.cut()
@@ -69,8 +72,13 @@ def matchmaking(
             input_ = yield game
 
 
-def _is_game_allowed(user1: User, user2: User) -> bool:
-    rank1 = user1.rank()
-    rank2 = user2.rank()
+def _is_game_allowed(
+    user1: User,
+    user2: User,
+    max_rating: EloRating,
+    users_with_max_rating: UsersWithMaxRating,
+) -> bool:
+    rank1 = user1.rank(max_rating, users_with_max_rating)
+    rank2 = user2.rank(max_rating, users_with_max_rating)
 
     return rank1 == rank2 or are_ranks_adjacent(rank1, rank2)

src/ttt/entities/core/user/rank.py

@@ -5,23 +5,46 @@
 from ttt.entities.elo.rating import EloRating
 
 
-type RankTier = Literal[-1, 0, 1, 2, 3, 4]
+type RankTier = Literal[-1, 0, 1, 2, 3, 4, 5]
 
 
 @dataclass(frozen=True)
-class Rank:
+class IntervalRank:
     tier: RankTier
     min_rating: EloRating
     max_rating: EloRating
 
 
+@dataclass(frozen=True)
+class SpecialRank[TierT: RankTier, NameT: str]:
+    tier: TierT
+    name: NameT
+
+
+StrongestRank = SpecialRank[Literal[5], Literal["strongest"]]
+strongest_rank = StrongestRank(tier=5, name="strongest")
+
+special_ranks = (
+    strongest_rank,
+)
+
+
+type Rank = IntervalRank | StrongestRank
+
+
+interval_ranks = (
+    IntervalRank(tier=-1, min_rating=-math.inf, max_rating=871),
+    IntervalRank(tier=0, min_rating=872, max_rating=1085),
+    IntervalRank(tier=1, min_rating=1086, max_rating=1336),
+    IntervalRank(tier=2, min_rating=1337, max_rating=1679),
+    IntervalRank(tier=3, min_rating=1680, max_rating=1999),
+    IntervalRank(tier=4, min_rating=2000, max_rating=math.inf),
+)
+
+
 ranks = (
-    Rank(tier=-1, min_rating=-math.inf, max_rating=871),
-    Rank(tier=0, min_rating=872, max_rating=1085),
-    Rank(tier=1, min_rating=1086, max_rating=1336),
-    Rank(tier=2, min_rating=1337, max_rating=1679),
-    Rank(tier=3, min_rating=1680, max_rating=1999),
-    Rank(tier=4, min_rating=2000, max_rating=math.inf),
+    *interval_ranks,
+    *special_ranks,
 )
 
 
@@ -33,8 +56,18 @@ def rank_with_tier(tier: RankTier) -> Rank:
     raise ValueError
 
 
-def rank_for_rating(rating: EloRating) -> Rank:
-    for rank in ranks:
+type UsersWithMaxRating = Literal["1", ">1"]
+
+
+def rank(
+    rating: EloRating,
+    max_rating: EloRating,
+    users_with_max_rating: UsersWithMaxRating,
+) -> Rank:
+    if rating == max_rating and users_with_max_rating == "1":
+        return strongest_rank
+
+    for rank in interval_ranks:
         if rank.min_rating <= rating <= rank.max_rating:
             return rank
 

src/ttt/entities/core/user/user.py

@@ -14,7 +14,7 @@
 from ttt.entities.core.user.emoji import UserEmoji
 from ttt.entities.core.user.loss import UserLoss
 from ttt.entities.core.user.matchmaking_waiting import MatchmakingWaiting
-from ttt.entities.core.user.rank import Rank, rank_for_rating
+from ttt.entities.core.user.rank import Rank, UsersWithMaxRating, rank
 from ttt.entities.core.user.win import UserWin
 from ttt.entities.elo.rating import (
     EloRating,
@@ -97,8 +97,10 @@ class User:
 
     emoji_cost: ClassVar[Stars] = 1000
 
-    def rank(self) -> Rank:
-        return rank_for_rating(self.rating)
+    def rank(
+        self, max_rating: EloRating, users_with_max_rating: UsersWithMaxRating,
+    ) -> Rank:
+        return rank(self.rating, max_rating, users_with_max_rating)
 
     def is_admin(self) -> bool:
         return is_user_admin(self.admin_right)

src/ttt/infrastructure/adapters/users.py

@@ -6,7 +6,12 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ttt.application.user.common.ports.users import Users
+from ttt.entities.core.user.rank import UsersWithMaxRating
 from ttt.entities.core.user.user import User
+from ttt.entities.elo.rating import EloRating
+from ttt.infrastructure.sqlalchemy.stmts import (
+    max_rating_and_users_with_max_rating_from_postgres,
+)
 from ttt.infrastructure.sqlalchemy.tables.user import TableUser
 
 
@@ -69,3 +74,10 @@ async def some_users_waiting_for_matchmaking_to_matchmake(
         table_users = result.all()
 
         return [table_user.entity() for table_user in table_users]
+
+    async def max_rating_and_users_with_max_rating(
+        self,
+    ) -> tuple[EloRating, UsersWithMaxRating]:
+        return await max_rating_and_users_with_max_rating_from_postgres(
+            self._session,
+        )

src/ttt/infrastructure/alembic/versions/6642791b3bf8_index_users_rating.py

@@ -0,0 +1,30 @@
+"""
+index `users.rating`.
+
+Revision ID: 6642791b3bf8
+Revises: 7ce97d6efd2c
+Create Date: 2025-09-20 08:16:00.242481
+
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+
+revision: str = "6642791b3bf8"
+down_revision: str | None = "7ce97d6efd2c"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_index(op.f("ix_users_rating"), "users", ["rating"], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_users_rating"), table_name="users")
+    # ### end Alembic commands ###

src/ttt/infrastructure/sqlalchemy/stmts.py

@@ -1,9 +1,12 @@
 from collections.abc import Sequence
 from typing import cast
 
-from sqlalchemy import exists, select
+from sqlalchemy import exists, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from ttt.entities.core.user.rank import UsersWithMaxRating
+from ttt.entities.elo.rating import EloRating
+from ttt.entities.tools.assertion import not_none
 from ttt.infrastructure.sqlalchemy.tables.user import TableUser, TableUserEmoji
 
 
@@ -39,3 +42,28 @@ async def selected_user_emoji_str_from_postgres(
 async def user_exists_in_postgres(session: AsyncSession, user_id: int) -> bool:
     stmt = select(exists(1).where(TableUser.id == user_id))
     return bool(await session.scalar(stmt))
+
+
+async def max_rating_and_users_with_max_rating_from_postgres(
+    session: AsyncSession,
+) -> tuple[EloRating, UsersWithMaxRating]:
+    max_rating_stmt = select(func.max(TableUser.rating))
+    max_rating = not_none(await session.scalar(max_rating_stmt))
+
+    raw_users_with_max_rating_stmt = (
+        select(func.count(1))
+        .select_from(
+            select(1)
+            .where(TableUser.rating == max_rating)
+            .limit(2)
+            .subquery(),
+        )
+    )
+    raw_users_with_max_rating = not_none(
+        await session.scalar(raw_users_with_max_rating_stmt),
+    )
+    users_with_max_rating: UsersWithMaxRating = (
+        "1" if raw_users_with_max_rating == 1 else ">1"
+    )
+
+    return max_rating, users_with_max_rating

src/ttt/infrastructure/sqlalchemy/tables/user.py

@@ -80,7 +80,7 @@ class TableUser(Base[User]):
     selected_emoji_id: Mapped[UUID | None] = mapped_column(
         ForeignKey("user_emojis.id", deferrable=True, initially="DEFERRED"),
     )
-    rating: Mapped[float]
+    rating: Mapped[float] = mapped_column(index=True)
     current_game_id: Mapped[UUID | None] = mapped_column(
         ForeignKey("games.id", deferrable=True, initially="DEFERRED"),
     )

src/ttt/presentation/adapters/user_views.py

@@ -24,6 +24,7 @@
 from ttt.entities.core.user.user import User, is_user_in_game, user_stars
 from ttt.entities.tools.assertion import not_none
 from ttt.infrastructure.sqlalchemy.stmts import (
+    max_rating_and_users_with_max_rating_from_postgres,
     selected_user_emoji_str_from_postgres,
     user_emojis_from_postgres,
 )
@@ -121,12 +122,20 @@ async def view_of_user_with_id(
         )
         defeats = not_none(await self._session.scalar(defeats_stmt))
 
+        max_rating, users_with_max_rating = (
+            await max_rating_and_users_with_max_rating_from_postgres(
+                self._session,
+            )
+        )
+
         view = UserProfileView.of(
             wins,
             draws,
             defeats,
             user_row.account_stars,
             user_row.rating,
+            max_rating,
+            users_with_max_rating,
         )
         self._result_buffer.result = view
 
@@ -177,6 +186,11 @@ async def user_menu_view(self, user_id: int, /) -> None:
         else:
             amout_of_incoming_invitations_to_game = "many"
 
+        max_rating, users_with_max_rating = (
+            await max_rating_and_users_with_max_rating_from_postgres(
+                self._session,
+            )
+        )
         view = MainMenuView(
             is_user_in_game=is_user_in_game(row.current_game_id),
             has_user_emojis=row.has_user_emojis,
@@ -185,6 +199,8 @@ async def user_menu_view(self, user_id: int, /) -> None:
             amout_of_incoming_invitations_to_game=(
                 amout_of_incoming_invitations_to_game
             ),
+            max_rating=max_rating,
+            users_with_max_rating=users_with_max_rating,
         )
         self._result_buffer.result = view
 
@@ -387,6 +403,12 @@ async def other_user_view(self, user: User, other_user_id: int, /) -> None:
                 row.admin_right_via_other_admin_admin_id,
             )
 
+        max_rating, users_with_max_rating = (
+            await max_rating_and_users_with_max_rating_from_postgres(
+                self._session,
+            )
+        )
+
         view = OtherUserProfileView.of(
             other_user_id,
             admin_right,
@@ -395,6 +417,8 @@ async def other_user_view(self, user: User, other_user_id: int, /) -> None:
             defeats,
             row.account_stars,
             row.rating,
+            max_rating,
+            users_with_max_rating,
         )
 
         manager = self._dialog_manager_for_user(user.id)