✨Short term solution for disconnect before Ancient problem

Author: Aluerie

sql/2_dota.sql

@@ -21,7 +21,8 @@ CREATE TABLE
         lobby_type INT NOT NULL,
         game_mode INT NOT NULL,
         outcome INT DEFAULT (NULL),
-        live INT DEFAULT (1);
+        live INT DEFAULT (1),
+        failed INT DEFAULT (0)
     );
 
 CREATE TABLE

src/core/bot.py

@@ -162,6 +162,7 @@ class IreBot(commands.AutoBot):
         * etc.
 
     Maybe I will change this in future to be less confusing, but I think current situation is fine.
+
     """
 
     if TYPE_CHECKING:
@@ -550,7 +551,7 @@ def error_ping(self) -> str:
         """Error Role ping used to notify the developer(-s) about some errors."""
         return "<@&1337106675433340990>" if self.test else "<@&1116171071528374394>"
 
-    # UTILITIES
+    # UTILITIES AND SHORTCUTS
 
     def is_online(self, user_id: str) -> bool:
         """Whether the user is online.
@@ -559,3 +560,7 @@ def is_online(self, user_id: str) -> bool:
         For proper request - we need to use twitchio's `.fetch_streams` method.
         """
         return s.online if (s := self.streamers.get(user_id, None)) else False
+
+    def get_partial_owner(self) -> twitchio.PartialUser:
+        """A shortcut to get a partial user object for the bot's owner."""
+        return self.create_partialuser(self.owner_id)

src/modules/personal/stable.py

@@ -93,7 +93,7 @@ class StableCommands(IrePersonalComponent):
     """Stable commands.
 
     Stable in a sense that unlike commands in `temporary.py`
-    these commands are unlikely to be axed  for a long time.
+    these commands are unlikely to be deleted from my channel for a long time.
 
     Notes
     -----

src/modules/personal/timers.py

@@ -7,7 +7,7 @@
 
 from twitchio.ext import commands
 
-from core import IrePersonalComponent
+from core import IrePersonalComponent, ireloop
 from utils import const
 
 if TYPE_CHECKING:
@@ -65,6 +65,7 @@ async def stream_online_start_the_task(self, online: twitchio.StreamOffline) ->
         self.index = 0
         self.lines_count = 0
         self.bot.add_listener(self.count_messages, event="event_message")
+        self.boink_announcement.start()
 
     @commands.Component.listener(name="stream_offline")
     async def stream_offline_cancel_the_task(self, offline: twitchio.StreamOffline) -> None:
@@ -73,6 +74,7 @@ async def stream_offline_cancel_the_task(self, offline: twitchio.StreamOffline)
             return
 
         self.bot.remove_listener(self.count_messages)
+        self.boink_announcement.cancel()
 
     # @commands.Component.listener(name="message")
     async def count_messages(self, message: twitchio.ChatMessage) -> None:
@@ -106,6 +108,15 @@ async def count_messages(self, message: twitchio.ChatMessage) -> None:
                 self.lines_count = 0
                 self._most_recent = datetime.datetime.now(datetime.UTC)
 
+    @ireloop(hours=5)
+    async def boink_announcement(self) -> None:
+        """It's time to boink."""
+        if self.boink_announcement.current_loop == 0:
+            return
+
+        owner = self.bot.get_partial_owner()
+        await owner.send_announcement(message="It's time to Boink", moderator=self.bot.bot_id, color="primary")
+
 
 async def setup(bot: IreBot) -> None:
     """Load IreBot module. Framework of twitchio."""

src/modules/public/dota_rp_flow/component.py

@@ -100,16 +100,31 @@ class Dashboard(Activity): ...
 
 @dataclass(slots=True)
 class PlayingPartial(Activity):
+    """Partial Playing Match.
+
+    Partial in a sense that full `PlayingMatch` objects get built from objects of `PlayingPartial` class.
+    """
+
     watchable_game_id: str
 
 
 @dataclass(slots=True)
 class SpectatingPartial(Activity):
+    """Partial Spectating Match.
+
+    Partial in a sense that full `SpectatingMatch` objects get built from objects of `SpectatingPartial` class.
+    """
+
     watching_server: str
 
 
 @dataclass(slots=True)
 class UnsupportedPartial(Activity):
+    """Partial Unsupported Match.
+
+    Partial in a sense that full `UnsupportedMatch` objects get built from objects of `UnsupportedPartial` class.
+    """
+
     msg: str
 
 
@@ -1130,10 +1145,9 @@ async def process_pending_matches(self) -> None:
         log.debug("Processing pending matches.")
 
         query = """
-            SELECT m.match_id
-            FROM ttv_dota_matches m
-            JOIN ttv_dota_match_players p ON m.match_id = p.match_id
-            WHERE m.outcome IS NULL AND m.live = $1;
+            SELECT match_id, failed
+            FROM ttv_dota_matches
+            WHERE outcome IS NULL AND live = $1 AND failed < 12;
         """
         rows = await self.bot.pool.fetch(query, LiveIndicator.Pending)
         if not rows:
@@ -1142,7 +1156,23 @@ async def process_pending_matches(self) -> None:
             return
 
         for row in rows:
-            minimal = await self.bot.dota.create_partial_match(row["match_id"]).minimal()
+            try:
+                # If streamer disconnects before ancient falls (i.e., preemptive disconnects or when game is "Safe to leave")
+                # Then `.minimal` won't give any results as the game is still live but streamer's RP is different
+                # So we need to deal with errors of not getting response from it.
+                # This also happens if streamer disconnects-reconnects in the middle of the match.
+                minimal = await self.bot.dota.create_partial_match(row["match_id"]).minimal()
+            except ValueError:
+                # this way any matches that errored out more 12 times gonna be ignored
+                # not sure how I feel about such solution;
+                query = """
+                    UPDATE ttv_dota_matches
+                    SET failed = failed + 1
+                    WHERE match_id = $1;
+                """
+                await self.bot.pool.execute(query, row["match_id"])
+                continue
+
             query = """
                 UPDATE ttv_dota_matches
                 SET outcome = $1, live = $3