Merge disc and twitchio Cogs.

src/meta/CrocBot.py

@@ -10,10 +10,6 @@ from data import Database
 from .config import Conf
 
 
-if TYPE_CHECKING:
-    from .LionBot import LionBot
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -21,12 +17,11 @@ class CrocBot(commands.Bot):
     def __init__(self, *args,
                  config: Conf,
                  data: Database,
-                 lionbot: 'LionBot', **kwargs):
+                 **kwargs):
         super().__init__(*args, **kwargs)
         self.config = config
         self.data = data
         self.pubsub = pubsub.PubSubPool(self)
-        self.lionbot = lionbot
 
     async def event_ready(self):
         logger.info(f"Logged in as {self.nick}. User id is {self.user_id}")

src/meta/LionBot.py

@@ -24,6 +24,7 @@ from .errors import HandledException, SafeCancellation
 from .monitor import SystemMonitor, ComponentMonitor, StatusLevel, ComponentStatus
 
 if TYPE_CHECKING:
+    from meta.CrocBot import CrocBot
     from core.cog import CoreCog
     from core.config import ConfigCog
     from tracking.voice.cog import VoiceTrackerCog
@@ -58,6 +59,7 @@ class LionBot(Bot):
         initial_extensions: List[str], web_client: ClientSession, app_ipc,
         testing_guilds: List[int] = [],
         system_monitor: Optional[SystemMonitor] = None,
+        crocbot: Optional['CrocBot'] = None,
         **kwargs
     ):
         kwargs.setdefault('tree_cls', LionTree)
@@ -73,6 +75,8 @@ class LionBot(Bot):
         self.app_ipc = app_ipc
         self.translator = translator
 
+        self.crocbot = crocbot
+
         self.system_monitor = system_monitor or SystemMonitor()
         self.monitor = ComponentMonitor('LionBot', self._monitor_status)
         self.system_monitor.add_component(self.monitor)

src/meta/LionCog.py

@@ -1,23 +1,35 @@
-from typing import Any
+from functools import partial
+from typing import Any, Callable, Optional
 
 from discord.ext.commands import Cog
 from discord.ext import commands as cmds
+from twitchio.ext.commands import Command, Bot
+from twitchio.ext.commands.meta import CogEvent
 
 
 class LionCog(Cog):
     # A set of other cogs that this cog depends on
     depends_on: set['LionCog'] = set()
     _placeholder_groups_: set[str]
+    _twitch_cmds_: dict[str, Command]
+    _twitch_events_: dict[str, CogEvent]
+    _twitch_events_loaded_: set[Callable]
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
 
         cls._placeholder_groups_ = set()
+        cls._twitch_cmds_ = {}
+        cls._twitch_events_ = {}
 
         for base in reversed(cls.__mro__):
             for elem, value in base.__dict__.items():
                 if isinstance(value, cmds.HybridGroup) and hasattr(value, '_placeholder_group_'):
                     cls._placeholder_groups_.add(value.name)
+                elif isinstance(value, Command):
+                    cls._twitch_cmds_[value.name] = value
+                elif isinstance(value, CogEvent):
+                    cls._twitch_events_[value.name] = value
 
     def __new__(cls, *args: Any, **kwargs: Any):
         # Patch to ensure no placeholder groups are in the command list
@@ -34,6 +46,33 @@ class LionCog(Cog):
 
         return await super()._inject(bot, *args, *kwargs)
 
+    def _load_twitch_methods(self, bot: Bot):
+        for name, command in self._twitch_cmds_.items():
+            command._instance = self
+            command.cog = self
+            bot.add_command(command)
+
+        for name, event in self._twitch_events_.items():
+            callback = partial(event, self)
+            self._twitch_events_loaded_.add(callback)
+            bot.add_event(callback=callback, name=name)
+
+    def _unload_twitch_methods(self, bot: Bot):
+        for name in self._twitch_cmds_:
+            bot.remove_command(name)
+
+        for callback in self._twitch_events_loaded_:
+            bot.remove_event(callback=callback)
+
+        self._twitch_events_loaded_.clear()
+
+    @classmethod
+    def twitch_event(cls, event: Optional[str] = None):
+        def decorator(func) -> CogEvent:
+            event_name = event or func.__name__
+            return CogEvent(name=event_name, func=func, module=cls.__module__)
+        return decorator
+
     @classmethod
     def placeholder_group(cls, group: cmds.HybridGroup):
         group._placeholder_group_ = True