Add ctx.reply (#223)

Author: chillymosh

twitchio/abcs.py

@@ -63,6 +63,10 @@ def _fetch_channel(self):
     def _fetch_websocket(self):
         raise NotImplementedError
 
+    @abc.abstractmethod
+    def _fetch_message(self):
+        raise NotImplementedError
+
     @abc.abstractmethod
     def _bot_is_mod(self):
         raise NotImplementedError
@@ -121,3 +125,39 @@ async def send(self, content: str):
             await ws.send(f"PRIVMSG #jtv :/w {name} {content}\r\n")
         else:
             await ws.send(f"PRIVMSG #{name} :{content}\r\n")
+
+    async def reply(self, content: str):
+        """|coro|
+
+
+        Send a message in reply to the user who sent a message in the destination
+        associated with the dataclass.
+
+        Destination will be the context of which the message/command was sent.
+
+        Parameters
+        ------------
+        content: str
+            The content you wish to send as a message. The content must be a string.
+
+        Raises
+        --------
+        InvalidContent
+            Invalid content.
+        """
+        entity = self._fetch_channel()
+        ws = self._fetch_websocket()
+        message = self._fetch_message()
+
+        self.check_content(content)
+        self.check_bucket(channel=entity.name)
+
+        try:
+            name = entity.channel.name
+        except AttributeError:
+            name = entity.name
+
+        if entity.__messageable_channel__:
+            await ws.reply(message.id, f"PRIVMSG #{name} :{content}\r\n")
+        else:
+            await ws.send(f"PRIVMSG #jtv :/w {name} {content}\r\n")

twitchio/channel.py

@@ -39,7 +39,7 @@
 
 class Channel(Messageable):
 
-    __slots__ = ("_name", "_ws")
+    __slots__ = ("_name", "_ws", "_message")
 
     __messageable_channel__ = True
 
@@ -62,6 +62,9 @@ def _fetch_channel(self):
     def _fetch_websocket(self):
         return self._ws  # Abstract method
 
+    def _fetch_message(self):
+        return self._message  # Abstract method
+
     def _bot_is_mod(self):
         cache = self._ws._cache[self.name]  # noqa
         for user in cache:

twitchio/chatter.py

@@ -43,6 +43,7 @@ def __init__(self, websocket, **kwargs):
         self._name = kwargs.get("name")
         self._ws = websocket
         self._channel = kwargs.get("channel", self._name)
+        self._message = kwargs.get("message")
 
     def __repr__(self):
         return f"<PartialChatter name: {self._name}, channel: {self._channel}>"
@@ -80,6 +81,9 @@ def _fetch_channel(self):
     def _fetch_websocket(self):
         return self._ws  # Abstract method
 
+    def _fetch_message(self):
+        return self._message  # Abstract method
+
     def _bot_is_mod(self):
         return False
 

twitchio/ext/commands/bot.py

@@ -232,7 +232,7 @@ async def get_context(self, message, *, cls=None):
         try:
             command_ = parsed.pop(0)
         except KeyError:
-            raise CommandNotFound(f"No valid command was passed.")
+            raise CommandNotFound("No valid command was passed.")
 
         try:
             command_ = self._command_aliases[command_]

twitchio/ext/commands/core.py

@@ -154,7 +154,7 @@ async def parse_args(self, context: Context, instance: Optional[Cog], parsed: di
             if instance:
                 next(iterator)
         except StopIteration:
-            raise TwitchCommandError(f"self or ctx is a required argument which is missing.")
+            raise TwitchCommandError("self or ctx is a required argument which is missing.")
 
         for _, param in iterator:
             index += 1
@@ -401,6 +401,9 @@ def _fetch_channel(self) -> Messageable:
     def _fetch_websocket(self):
         return self._ws  # Abstract method
 
+    def _fetch_message(self):
+        return self.message  # Abstract method
+
     def _bot_is_mod(self) -> bool:
         if not self.channel:
             return False

twitchio/message.py

@@ -33,7 +33,7 @@
 
 class Message:
 
-    __slots__ = ("_raw_data", "content", "_author", "echo", "_timestamp", "_channel", "_tags")
+    __slots__ = ("_raw_data", "content", "_author", "echo", "_timestamp", "_channel", "_tags", "_id")
 
     def __init__(self, **kwargs):
         self._raw_data = kwargs.get("raw_data")
@@ -44,10 +44,17 @@ def __init__(self, **kwargs):
         self.echo = kwargs.get("echo", False)
 
         try:
+            self._id = self._tags["id"]
             self._timestamp = self._tags["tmi-sent-ts"]
         except KeyError:
+            self._id = None
             self._timestamp = time.time()
 
+    @property
+    def id(self) -> str:
+        """The Message ID."""
+        return self._id
+
     @property
     def author(self) -> Union["Chatter", "PartialChatter"]:
         """The User object associated with the Message."""

twitchio/models.py

@@ -662,7 +662,6 @@ def colour(self) -> str:
     def __repr__(self):
         return f"<PredictionOutcome outcome_id={self.outcome_id} title={self.title} channel_points={self.channel_points} color={self.color}>"
 
-
 class Schedule:
 
     __slots__ = ("segments", "user", "vacation")

twitchio/user.py

@@ -783,7 +783,6 @@ async def fetch_schedule(
 
         return Schedule(self._http, data)
 
-
 class BitLeaderboardUser(PartialUser):
 
     __slots__ = "rank", "score"

twitchio/websocket.py

@@ -200,6 +200,21 @@ async def send(self, message: str):
 
         await self._websocket.send_str(message + "\r\n")
 
+    async def reply(self, msg_id: str, message: str):
+        message = message.strip()
+        log.debug(f" > {message}")
+
+        if message.startswith("PRIVMSG #"):
+            data = message.replace("PRIVMSG #", "", 1).split(" ")
+            channel = data.pop(0)
+            content = " ".join(data)
+
+            dummy = f"> @reply-parent-msg-id={msg_id} :{self.nick}!{self.nick}@{self.nick}.tmi.twitch.tv PRIVMSG(ECHO) #{channel} {content}\r\n"
+            task = asyncio.create_task(self._process_data(dummy))
+            task.add_done_callback(partial(self._task_callback, dummy))  # Process our raw data
+
+        await self._websocket.send_str(f"@reply-parent-msg-id={msg_id} {message} \r\n")
+
     async def authenticate(self, channels: Union[list, tuple]):
         """|coro|
 
@@ -435,7 +450,7 @@ async def _mode(self, parsed):  # TODO
         pass
 
     async def _reconnect(self, parsed):
-        log.debug(f"ACTION: RECONNECT:: Twitch has gracefully closed the connection and will reconnect.")
+        log.debug("ACTION: RECONNECT:: Twitch has gracefully closed the connection and will reconnect.")
         self._reconnect_requested = True
 
     def dispatch(self, event: str, *args, **kwargs):