Use Timers instead of bools to filter opponents to allow temporary stops to challenges (#1141)

* Make matchmaking challenge filters time-limited

This will allow for filters to expire in case challenge declinations are
for temporary reasons. Also, in the case of an opponent reaching the
100-game daily limit, this will be useful for trying again in the time
given in the interval.

* Factor out variable

* Distinguish between bot limit and opponent limit

In an upcoming lichess update, challenging an opponent that has played 100 bot games will result in a similar error response to when the user's bot has played 100 bot games. This change distinguishes between them by checking if the error message contains the opponent's name.

This could also be distinguished by checking if the status code is 429 (user's bot) or 400 (opponent bot). But that information isn't returned from the Lichess.challenge() call.

* Be more specific about challenge pause delay

* Factor out function to get timeout from error

* Use status code to tell who is rate limited

A status code of 400 indicates that the opponent is rate limited, while
429 indicates that the bot is limited.

Also, put who is rate limited (if anyone) in the challenge response so
the Matchmaking class can use it.

* Simplify challenge control flow

* Only set rate limit when bot gets 429 status code

Don't set rate limit when opponent is rate limited (400 status code).

* Create a method to handle responses to challenges

Author: MarkZH

lib/lichess.py

@@ -71,6 +71,36 @@ def is_new_rate_limit(response: requests.models.Response) -> bool:
     """Check if the status code is 429, which means that we are rate limited."""
     return response.status_code == 429
 
+def is_daily_game_rate_limit(response: requests.models.Response, rate_limit_status_code: int) -> bool:
+    """Check if response to challenge is a rate limit, either of the bot or the opponent."""
+    if response.status_code != rate_limit_status_code:
+        return False
+
+    try:
+        body = response.json()
+        return "error" in body and body.get("ratelimit", {}).get("key", "") == "bot.vsBot.day"
+    except requests.exceptions.JSONDecodeError:
+        return False
+
+
+def is_opponent_rate_limit(response: requests.models.Response) -> bool:
+    """Check if response to a challenge is 400, which means opponent is rate limited."""
+    return is_daily_game_rate_limit(response, 400)
+
+
+def is_bot_rate_limit(response: requests.models.Response) -> bool:
+    """Check if response to a challenge is 429, which means the bot is rate limited."""
+    return is_daily_game_rate_limit(response, 429)
+
+
+def get_challenge_timeout(challenge_response: ChallengeType) -> Optional[datetime.timedelta]:
+    """Return the timeout in a challenge response if the bot or the opponent cannot play another game."""
+    rate_limit = challenge_response.get("ratelimit", {})
+    key = rate_limit.get("key", "")
+    if key == "bot.vsBot.day":
+        return seconds(float(rate_limit["seconds"]))
+    return None
+
 
 def is_final(exception: Exception) -> bool:
     """If `is_final` returns True then we won't retry."""
@@ -240,18 +270,11 @@ def api_post(self,
         url = urljoin(self.baseUrl, path_template.format(*template_args))
         response = self.session.post(url, data=data, headers=headers, params=params, json=payload, timeout=2)
 
+        if endpoint_name == "challenge":
+            return self.handle_challenge(response)
+
         if is_new_rate_limit(response):
-            delay = seconds(60)
-            try:
-                if endpoint_name == "challenge":
-                    body = response.json()
-                    rate_limit = body.get("ratelimit", {})
-                    key = rate_limit.get("key", "")
-                    if key == "bot.vsBot.day":
-                        delay = seconds(rate_limit["seconds"])
-            except requests.exceptions.JSONDecodeError:
-                pass
-            self.set_rate_limit_delay(path_template, delay)
+            self.set_rate_limit_delay(path_template, seconds(60))
 
         if raise_for_status:
             response.raise_for_status()
@@ -268,11 +291,26 @@ def get_path_template(self, endpoint_name: str) -> str:
         """
         path_template = ENDPOINTS[endpoint_name]
         if self.is_rate_limited(path_template):
-            raise RateLimitedError(f"{path_template} is rate-limited. "
-                                   f"Will retry in {sec_str(self.rate_limit_time_left(path_template))} seconds.",
-                                   self.rate_limit_time_left(path_template))
+            time_left = self.rate_limit_time_left(path_template)
+            raise RateLimitedError(
+                f"{path_template} is rate-limited. Will retry in {sec_str(time_left)} seconds.", time_left)
         return path_template
 
+    def handle_challenge(self, response: requests.models.Response) -> ChallengeType:
+        """Handle the response to a challenge and, if necessary, the daily game timeout."""
+        bot_is_rate_limited = is_bot_rate_limit(response)
+        opponent_is_rate_limited = is_opponent_rate_limit(response)
+        challenge_response: ChallengeType = response.json()
+        if bot_is_rate_limited or opponent_is_rate_limited:
+            delay = cast(datetime.timedelta, get_challenge_timeout(challenge_response))
+            if bot_is_rate_limited:
+                self.set_rate_limit_delay(ENDPOINTS["challenge"], delay)
+            challenge_response["bot_is_rate_limited"] = bot_is_rate_limited
+            challenge_response["opponent_is_rate_limited"] = opponent_is_rate_limited
+            challenge_response["rate_limit_timeout"] = delay
+
+        return challenge_response
+
     def set_rate_limit_delay(self, path_template: str, delay_time: datetime.timedelta) -> None:
         """
         Set a delay to a path template if it was rate limited.

lib/lichess_types.py

@@ -4,6 +4,7 @@
 from chess import Move, Board
 from queue import Queue
 import logging
+import datetime
 from enum import Enum
 from types import TracebackType
 
@@ -188,7 +189,11 @@ class ChallengeType(TypedDict, total=False):
     declineReason: str
     declineReasonKey: str
     initialFen: str
-    error: dict[str, Union[str, dict[str, str]]]
+    error: str
+    ratelimit: dict[str, Union[str, int]]
+    bot_is_rate_limited: bool
+    opponent_is_rate_limited: bool
+    rate_limit_timeout: datetime.timedelta
 
 
 class EventType(TypedDict, total=False):

lib/matchmaking.py

@@ -4,7 +4,7 @@
 import datetime
 import contextlib
 from lib import model
-from lib.timer import Timer, seconds, minutes, years
+from lib.timer import Timer, days, seconds, minutes, years
 from collections import defaultdict
 from collections.abc import Sequence
 from lib.lichess import Lichess, RateLimitedError
@@ -41,7 +41,7 @@ def __init__(self, li: Lichess, config: Configuration, user_profile: UserProfile
         #   - variant (standard, horde, etc.)
         #   - casual/rated
         #   - empty string (if no other reason is given or self.filter_type is COARSE)
-        self.challenge_type_acceptable: defaultdict[tuple[str, str], bool] = defaultdict(lambda: True)
+        self.challenge_type_acceptable: defaultdict[tuple[str, str], Timer] = defaultdict(Timer)
         self.challenge_filter = self.matchmaking_cfg.challenge_filter
 
         for name in self.matchmaking_cfg.block_list:
@@ -95,16 +95,15 @@ def create_challenge(self, username: str, base_time: int, increment: int, days:
     def handle_challenge_error_response(self, response: ChallengeType, username: str) -> None:
         """If a challenge fails, print the error and adjust the challenge requirements in response."""
         logger.error(response)
-        if "error" in response:
-            rate_limit = cast(dict[str, str], response.get("ratelimit", {}))
-            key = rate_limit.get("key", "")
-            if key == "bot.vsBot.day":
-                self.rate_limit_timer = Timer(seconds(float(rate_limit["seconds"])))
+        if response.get("bot_is_rate_limited"):
+            timeout = cast(datetime.timedelta, response.get("rate_limit_timeout"))
+            self.rate_limit_timer = Timer(timeout)
+        elif response.get("opponent_is_rate_limited"):
+            self.add_challenge_filter(username, "", response.get("rate_limit_timeout"))
         else:
-            self.add_to_block_list(username)
+            self.add_challenge_filter(username, "")
         self.show_earliest_challenge_time()
 
-
     def perf(self) -> dict[str, PerfType]:
         """Get the bot's rating in every variant. Bullet, blitz, rapid etc. are considered different variants."""
         user_perf: dict[str, PerfType] = self.user_profile["perfs"]
@@ -263,22 +262,22 @@ def show_earliest_challenge_time(self) -> None:
 
     def add_to_block_list(self, username: str) -> None:
         """Add a bot to the blocklist."""
-        self.add_challenge_filter(username, "")
+        self.add_challenge_filter(username, "", years(10))
 
     def in_block_list(self, username: str) -> bool:
         """Check if an opponent is in the block list to prevent future challenges."""
         return not self.should_accept_challenge(username, "")
 
-    def add_challenge_filter(self, username: str, game_aspect: str) -> None:
+    def add_challenge_filter(self, username: str, game_aspect: str, timeout: Union[datetime.timedelta, None] = None) -> None:
         """
-        Prevent creating another challenge when an opponent has decline a challenge.
+        Prevent creating another challenge for a timeout when an opponent has declined a challenge.
 
         :param username: The name of the opponent.
-        :param game_aspect: The aspect of a game (time control, chess variant, etc.)
-        that caused the opponent to decline a challenge. If the parameter is empty,
-        that is equivalent to adding the opponent to the block list.
+        :param game_aspect: The aspect of a game (time control, chess variant, etc.) that caused the opponent to decline a
+        challenge. If the parameter is empty, that is equivalent to adding the opponent to the block list.
+        :param timeout: The amount of time to not challenge an opponent. If None, the default is a day.
         """
-        self.challenge_type_acceptable[(username, game_aspect)] = False
+        self.challenge_type_acceptable[(username, game_aspect)] = Timer(timeout or days(1))
 
     def should_accept_challenge(self, username: str, game_aspect: str) -> bool:
         """
@@ -288,7 +287,7 @@ def should_accept_challenge(self, username: str, game_aspect: str) -> bool:
         :param game_aspect: A category of the challenge type (time control, chess variant, etc.) to test for acceptance.
         If game_aspect is empty, this is equivalent to checking if the opponent is in the block list.
         """
-        return self.challenge_type_acceptable[(username, game_aspect)]
+        return self.challenge_type_acceptable[(username, game_aspect)].is_expired()
 
     def accepted_challenge(self, event: EventType) -> None:
         """
@@ -329,7 +328,7 @@ def declined_challenge(self, event: EventType) -> None:
             logger.warning(f"Unknown decline reason received: {reason_key}")
         game_problem = decline_details.get(reason_key, "") if self.challenge_filter == FilterType.FINE else ""
         self.add_challenge_filter(opponent.name, game_problem)
-        logger.info(f"Will not challenge {opponent} to another {game_problem}".strip() + " game.")
+        logger.info(f"Will not challenge {opponent} to another {game_problem}".strip() + " game today.")
 
         self.show_earliest_challenge_time()