fix(notify): use generic type to avoid check isinstance again

src/check_phat_nguoi/notify/engines/base.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from logging import getLogger
-from typing import Self
+from typing import Self, TypeVar
 
 from check_phat_nguoi.config import BaseNotificationEngineConfig
 
@@ -11,16 +11,18 @@
 logger = getLogger(__name__)
 
 
-class BaseNotificationEngine:
+T: TypeVar = TypeVar("T", bound=BaseNotificationEngineConfig)
+
+
+class BaseNotificationEngine[T]:
     async def __aenter__(self) -> Self:
         return self
 
     async def __aexit__(self, exc_type, exc_value, exc_traceback) -> None: ...
 
-    # FIXME: This is for inheritances. But it have to check inside this method one more time... Which is slow
     @abstractmethod
     async def send(
         self,
-        notification_config: BaseNotificationEngineConfig,
+        engine_config: T,
         plates_messages: tuple[MarkdownMessageDetail, ...],
     ) -> None: ...

src/check_phat_nguoi/notify/engines/discord.py

@@ -7,10 +7,7 @@
 from discord import Intents, NotFound, User
 from discord.ext.commands import Bot
 
-from check_phat_nguoi.config import (
-    BaseNotificationEngineConfig,
-    DiscordNotificationEngineConfig,
-)
+from check_phat_nguoi.config import DiscordNotificationEngineConfig
 
 from ..markdown_message import MarkdownMessageDetail
 from .base import BaseNotificationEngine
@@ -59,16 +56,14 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.bot.close()
 
 
-class DiscordNotificationEngine(BaseNotificationEngine):
+class DiscordNotificationEngine[BaseNotificationEngineConfig](BaseNotificationEngine):
     @override
     async def send(
         self,
-        notification_config: BaseNotificationEngineConfig,
+        engine_config: DiscordNotificationEngineConfig,
         plates_messages: tuple[MarkdownMessageDetail, ...],
     ) -> None:
-        if not isinstance(notification_config, DiscordNotificationEngineConfig):
-            return
         async with _DiscordNotificationCoreEngine(
-            notification_config, plates_messages
+            engine_config, plates_messages
         ) as core_engine:
             await core_engine.send()

src/check_phat_nguoi/notify/engines/telegram.py

@@ -7,9 +7,6 @@
 from aiohttp import ClientError
 
 from check_phat_nguoi.config import TelegramNotificationEngineConfig
-from check_phat_nguoi.config.models.notifications.base_engine import (
-    BaseNotificationEngineConfig,
-)
 from check_phat_nguoi.constants import SEND_MESSAGE_API_URL_TELEGRAM as API_URL
 from check_phat_nguoi.utils import HttpaioSession
 
@@ -19,7 +16,9 @@
 logger = getLogger(__name__)
 
 
-class TelegramNotificationEngine(BaseNotificationEngine, HttpaioSession):
+class TelegramNotificationEngine[BaseNotificationEngineConfig](
+    BaseNotificationEngine, HttpaioSession
+):
     def __init__(self) -> None:
         HttpaioSession.__init__(self)
 
@@ -58,15 +57,13 @@ async def _send_message(
     @override
     async def send(
         self,
-        notification_config: BaseNotificationEngineConfig,
+        engine_config: TelegramNotificationEngineConfig,
         plates_messages: tuple[MarkdownMessageDetail, ...],
     ) -> None:
-        if not isinstance(notification_config, TelegramNotificationEngineConfig):
-            return
         await asyncio.gather(
             *(
                 self._send_message(
-                    telegram=notification_config, message=message, plate=messages.plate
+                    telegram=engine_config, message=message, plate=messages.plate
                 )
                 for messages in plates_messages
                 for message in messages.messages

src/check_phat_nguoi/notify/send_notifications.py

@@ -3,14 +3,12 @@
 
 from check_phat_nguoi.config import (
     BaseNotificationConfig,
-    BaseNotificationEngineConfig,
     TelegramNotificationConfig,
 )
 from check_phat_nguoi.config.config_reader import config
 from check_phat_nguoi.config.models import DiscordNotificationConfig
 from check_phat_nguoi.context import plates_context
 
-from .engines.base import BaseNotificationEngine
 from .engines.discord import DiscordNotificationEngine
 from .engines.telegram import TelegramNotificationEngine
 from .markdown_message import MarkdownMessage, MarkdownMessageDetail
@@ -25,20 +23,14 @@ def __init__(self) -> None:
         self._discord_engine: DiscordNotificationEngine
 
     async def _send_messages(self, notification_config: BaseNotificationConfig) -> None:
-        engine: BaseNotificationEngine | None = None
-        engine_config: BaseNotificationEngineConfig | None = None
         if isinstance(notification_config, TelegramNotificationConfig):
-            engine = self._telegram_engine
-            engine_config = notification_config.telegram
+            await self._telegram_engine.send(
+                notification_config.telegram, self._plate_messages
+            )
         if isinstance(notification_config, DiscordNotificationConfig):
-            engine = self._telegram_engine
-            engine_config = notification_config.discord
-        if engine and engine_config:
-            await engine.send(engine_config, self._plate_messages)
-        else:
-            logger.error(
-                "There's a undefined notification engine or notification config"
-            )  # May never reach this case
+            await self._discord_engine.send(
+                notification_config.discord, self._plate_messages
+            )
 
     async def send(self) -> None:
         if config.notifications is None: