Fix: scheduled_tasks

Author: DirectiveAthena

src/AthenaTwitchBot/decorators/scheduled_task.py

@@ -48,16 +48,12 @@ def wrapper(*args, **kwargs):
                     channels.append(TwitchChannel(channel))
                 elif isinstance(channel, TwitchChannel):
                     channels.append(c)
-                else:
-                    return NotImplemented
-        else:
-            return NotImplemented
 
         wrapper.tsk = ScheduledTask(
             delay=convert_time_to_seconds(delay,to_int=True),
             wait_before=wait_before,
             callback=wrapper,
-            channels=channels
+            channels=channels if channels else None
         )
         return wrapper
     return decorator

src/AthenaTwitchBot/models/outputs/output_twitch.py

@@ -34,7 +34,10 @@ async def undefined(self,**kwargs):
 
     async def write(self, transport: asyncio.transports.Transport, context:TwitchContext, **kwargs):
         if context.output_text is not None:
-            transport.write(format_message(f"{PRIVMSG} {context.channel} :{context.output_text}"))
+            transport.write(
+                format_message(
+                    f"{PRIVMSG} {context.channel} :{context.output_text}"
+            ))
 
     async def reply(self, transport: asyncio.transports.Transport, context:TwitchContext, **kwargs):
         if context.output_text is not None and context.message_tags.message_id != EMPTY_STR:
@@ -43,7 +46,5 @@ async def reply(self, transport: asyncio.transports.Transport, context:TwitchCon
                     f"@reply-parent-msg-id={context.message_tags.message_id} {PRIVMSG} {context.channel} :{context.output_text}"
             ))
 
-
-
     async def scheduled_task(self,transport: asyncio.transports.Transport, context:TwitchContext, **kwargs):
         pass

src/AthenaTwitchBot/models/twitch_bot_protocol.py

@@ -53,19 +53,17 @@ async def scheduled_task_coro(self, tsk:ScheduledTask, channel:TwitchChannel):
                 tags=None,
                 user_name_str=self.bot.nickname,
                 channel_str=channel,
-                text=tuple()
+                text=tuple(),
+                raw_irc=[""]
             )
             if tsk.wait_before: # the wait_before attribute handles if we sleep wait_before or after the task has been called
                 await asyncio.sleep(tsk.delay)
                 tsk.callback(self=self.bot,context=context)
             else:
                 tsk.callback(self=self.bot,context=context)
                 await asyncio.sleep(tsk.delay)
-            self.output_handler(
-                callback=output_scheduled_task,
-                # below this point is all **kwargs
-                context=context
-            )
+
+            self.parse_context_output(context)
 
     def output_handler(self,callback:OUTPUT_CALLBACKS, **kwargs):
         # TODO test code below with asyncio.gather
@@ -79,7 +77,7 @@ def output_handler(self,callback:OUTPUT_CALLBACKS, **kwargs):
                 ,
                 loop=self.loop)
 
-    def create_context(self, tags:str|None, user_name_str:str, channel_str:str|TwitchChannel, text:tuple[str]) -> TwitchContext:
+    def create_context(self, raw_irc,tags:str|None, user_name_str:str, channel_str:str|TwitchChannel, text:tuple[str]) -> TwitchContext:
         return TwitchContext(
             message_tags=TwitchMessageTags.new_from_tags_str(tags)
                 if self.bot.twitch_capability_tags and tags is not None else
@@ -88,7 +86,8 @@ def create_context(self, tags:str|None, user_name_str:str, channel_str:str|Twitc
             channel=channel_str
                 if isinstance(channel_str, TwitchChannel) else
             TwitchChannel(channel_str) ,
-            raw_text=text
+            raw_text=text,
+            raw_irc=raw_irc
         )
 
     # ------------------------------------------------------------------------------------------------------------------
@@ -104,8 +103,11 @@ def connection_made(self, transport: asyncio.transports.Transport) -> None:
         )
 
         # add frequent_output methods to the coroutine loop
+
+        print(self.bot.scheduled_tasks)
+
         for tsk in self.bot.scheduled_tasks:
-            if tsk.channels: # the list is populated with channels
+            if tsk.channels is not None and tsk.channels: # the list is populated with channels
                 for channel in tsk.channels:
                     coro = self.loop.create_task(self.scheduled_task_coro(tsk, channel=channel))
                     asyncio.ensure_future(coro, loop=self.loop)
@@ -168,14 +170,8 @@ def parse_data(self, data: bytearray):
                     # PRIVMSG
                     # #directiveathena
                     # :that sentence was poggers
-                    if self.parse_user_message(tags, user_name_str, channel_str, text):
-                        # a command was caught:
-                        continue # because the output was handled by the parser above
-                    # else:
-                    self.output_handler(
-                        callback=output_undefined,
-                        # below this point is all **kwargs
-                        text=" ".join(d_split)
+                    self.parse_context_output(
+                        self.parse_user_message(d_split, tags, user_name_str, channel_str, text)
                     )
 
                 case str(user_name_str), _privmsg, str(channel_str), *text \
@@ -186,14 +182,8 @@ def parse_data(self, data: bytearray):
                     # PRIVMSG
                     # #directiveathena
                     # :that sentence was poggers
-                    if self.parse_user_message(None, user_name_str, channel_str, text):
-                        # a command was caught:
-                        continue # because the output was handled by the parser above
-                    # else:
-                    self.output_handler(
-                        callback=output_undefined,
-                        # below this point is all **kwargs
-                        text=" ".join(d_split)
+                    self.parse_context_output(
+                        self.parse_user_message(d_split, None, user_name_str, channel_str, text)
                     )
 
                 case str(bot_name_long), _join, str(channel) \
@@ -203,7 +193,6 @@ def parse_data(self, data: bytearray):
                     # :eva_athenabot!eva_athenabot@eva_athenabot.tmi.twitch.tv
                     # JOIN
                     # #directiveathena
-                    pass # todo functionality
                     self.output_handler(
                         callback=output_undefined,
                         # below this point is all **kwargs
@@ -217,7 +206,6 @@ def parse_data(self, data: bytearray):
                     # *
                     # ACK
                     # :twitch.tv/tags
-                    pass # todo functionality
                     self.output_handler(
                         callback=output_undefined,
                         # below this point is all **kwargs
@@ -235,7 +223,6 @@ def parse_data(self, data: bytearray):
                     # =
                     # #directiveathena
                     # :eva_athenabot
-                    pass # todo functionality
                     self.output_handler(
                         callback=output_undefined,
                         # below this point is all **kwargs
@@ -251,7 +238,6 @@ def parse_data(self, data: bytearray):
                     # =
                     # #directiveathena
                     # :eva_athenabot
-                    pass  # todo functionality
                     self.output_handler(
                         callback=output_undefined,
                         # below this point is all **kwargs
@@ -268,36 +254,42 @@ def parse_data(self, data: bytearray):
     # ------------------------------------------------------------------------------------------------------------------
     # - Message Parsing  -
     # ------------------------------------------------------------------------------------------------------------------
-    def parse_user_message(self, tags:str|None, user_name_str:str, channel_str:str, text:tuple[str]) -> bool:
-        context:TwitchContext = self.create_context(tags,user_name_str,channel_str,text)
-
+    def parse_user_message(self, raw_irc, tags:str|None, user_name_str:str, channel_str:str, text:tuple[str]) -> TwitchContext:
+        context:TwitchContext = self.create_context(raw_irc, tags,user_name_str,channel_str,text)
         PREFIX_FULL = f":{self.bot.prefix}"
 
-        if (cmd_str := context.raw_text[0]).startswith(PREFIX_FULL) and context.raw_text[0] != PREFIX_FULL:
-            context.is_command = True
-            context.command_str = cmd_str.replace(PREFIX_FULL, "").lower()
+        if (cmd_str := context.raw_text[0]).startswith(PREFIX_FULL) and cmd_str != PREFIX_FULL:
 
-            command:Command= self.bot.commands[context.command_str.lower()]
+            context.command_str = cmd_str.replace(PREFIX_FULL, "")
+            cmd_str_lower = context.command_str.lower()
 
-            #checvk if the command was case-sensitive and break if it is
-            if command.case_sensitive and context.command_str != context.command_str.lower():
-                return False
+            try:
+                command:Command = self.bot.commands[cmd_str_lower]
+                # check if the command was case-sensitive and break if it is
+                if command.case_sensitive and context.command_str != cmd_str_lower:
+                    raise KeyError
+            except KeyError:
+                return context
+
+            context.is_command = True
+            command.callback(self=self.bot,context=context)
 
-            #check if the user message is a command
-            if context.command_str.lower() in self.bot.commands:
-                command:Command
-                command.callback(self=self.bot,context=context)
+        return context
 
+    def parse_context_output(self, context:TwitchContext):
+        match context:
+            case TwitchContext(is_write=True):
                 self.output_handler(
-                    callback=output_reply if context.is_reply else output_write,
-                    # below this point is all **kwargs
+                    callback=output_write,
                     context=context
                 )
-                return True
-        return False
-
-
-
-
-
-
+            case TwitchContext(is_reply=True):
+                self.output_handler(
+                    callback=output_reply,
+                    context=context
+                )
+            case _:
+                self.output_handler(
+                    callback=output_undefined,
+                    text=" ".join(context.raw_irc)
+                )

src/AthenaTwitchBot/models/twitch_context.py

@@ -21,18 +21,21 @@ class TwitchContext:
     user:TwitchUser
     channel:TwitchChannel
     raw_text:tuple[str]
+    raw_irc:list[str]
 
     #some non init stuff
-    is_command:bool=field(init=False, default=False)
     command_str:str=field(init=False, default=None)
+    is_command:bool=field(init=False, default=False)
     is_reply:bool=field(init=False, default=False)
+    is_write:bool=field(init=False, default=False)
     output_text:str=field(init=False, default=None)
 
     def reply(self, text:str):
         self.is_reply = True
         self.output_text=self._cleanup_output_text(text)
 
     def write(self, text:str):
+        self.is_write = True
         self.output_text=self._cleanup_output_text(text)
 
     @staticmethod