Issue with using RawReactionActionEven.deffer and using RawReactionActionEvent.edit has been fixed

Author: mccoderpy

discord/abc.py

@@ -1032,7 +1032,6 @@ async def send(self, content=None, *, tts=False, embed=None, components=None, fi
                 elif isinstance(component, ActionRow):
                     components_list.extend(component.sendable())
             components = components_list
-            print(component)
 
 
         if allowed_mentions is not None:

discord/errors.py

@@ -230,6 +230,13 @@ class EmptyActionRow(DiscordException):
         You could supress this Error by setting :attr:`force` in the __init__ of the :class:`discord.ActionRow`  to :bool:`True`
     """
     def __init__(self):
-        msg = "The Discord-API alows you to send an empty ActionRow but wy should you do that? You will not see anything apearing in Discord.\n" \
-              "Note: this Error could be supressed by adding `force=True` to the Innit of the ActionRow"
+        msg = 'The Discord-API alows you to send an empty ActionRow but wy should you do that?' \
+              'You will not see anything apearing in Discord.\n' \
+              'Note: this Error could be supressed by adding `force=True` to the Innit of the ActionRow'
+        super().__init__(msg)
+
+class UnknowInteraction(DiscordException):
+    def __init__(self, interaction_id: int):
+        msg = f'You have already replied to this interaction ({interaction_id})' \
+              f' and/or 15 minutes have passed since the interaction, which is why Discord has deleted the interaction.'
         super().__init__(msg)

discord/http.py

@@ -447,18 +447,18 @@ def edit_message(self, channel_id, message_id, **fields):
         return self.request(r, json=fields)
 
     def post_initial_response(self, use_webhook, _resp, interaction_id, token, application_id):
-        r_url = f"/webhooks/{application_id}/{token}" if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback"
+        r_url = f"/webhooks/{application_id}/{token}/callback" if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback"
         r = Route("POST", r_url, self.V8BASE)
-        return self.request(r, json=_resp )
+        return self.request(r, json=_resp)
 
-    def edit_interaction_response(self, use_webhook, interaction_id, token, application_id, deffered, fields):
-        print(deffered)
+    def edit_interaction_response(self, use_webhook, interaction_id, token, application_id, deffered, **fields):
         if not deffered:
-            fields['type'] = 7
-            r = Route("POST", f"/webhooks/{application_id}/{token}" if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback", self.V8BASE)
+            base = {'data': fields}
+            base['type'] = 7
+            r = Route("POST", f'/webhooks/{application_id}/{token}/callback' if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback", self.V8BASE)
         else:
-            r = Route('PATCH', f"/webhooks/{application_id}/{token}/messages/@original" if use_webhook is True else f"/interactions/{application_id}/{token}/messages/@original", self.V8BASE)
-        print(fields)
+            base = fields
+            r = Route('PATCH', f'/webhooks/{application_id}/{token}/messages/@original', self.V8BASE)
         return self.request(r, json=fields)
 
     def add_reaction(self, channel_id, message_id, emoji):

discord/message.py

@@ -713,7 +713,7 @@ def _handle_embeds(self, value):
         self.embeds = [Embed.from_dict(data) for data in value]
 
     def _handle_components(self, value):
-        self.components = [DecodeMessageComponents for data in value]
+        self.components = [ActionRow.from_dict(data) for data in value]
 
     def _handle_nonce(self, value):
         self.nonce = value
@@ -1153,29 +1153,29 @@ async def edit(self, **fields):
             interaction_id = fields.pop('__interaction_id', None)
             interaction_token = fields.pop('__interaction_token', None)
             application_id = fields.pop('__application_id', None)
-            payload = {'data': fields}
-            if not deffered:
-                payload['type'] = 7
-            if payload:
+            if fields:
                 try:
                     data = await self._state.http.edit_interaction_response(use_webhook=use_webhook,
                                                                             interaction_id=interaction_id,
                                                                             token=interaction_token,
                                                                             application_id=application_id,
-                                                                            deffered=deffered,
-                                                                            fields=payload)
-                except Exception as exc:
-                    print (exc)
+                                                                            deffered=deffered,**fields)
+                except NotFound:
+                    is_interaction_responce = None
                     raise UnknowInteraction(application_id)
                 else:
-                    self._update(dict(data))
+                    [self.__setattr__(k, v) for k, v in fields.items()]
 
         elif is_interaction_responce is None:
             payload = await self._state.http.edit_message(self.channel.id, self.id, **fields)
             self._update(payload)
         if delete_after is not None:
             await self.delete(delay=delete_after)
 
+    @property
+    def dict(self):
+        return {s: self.__getattribute__(s) for s in self.__slots__ if not s.startswith('_')}
+
     async def publish(self):
         """|coro|
 
@@ -1686,17 +1686,18 @@ async def edit(self, **fields):
             interaction_id = fields.pop('__interaction_id', None)
             interaction_token = fields.pop('__interaction_token', None)
             application_id = fields.pop('__application_id', None)
-            payload = {'data': fields}
-            if payload:
+            if fields:
                 try:
                     data = await self._state.http.edit_interaction_response(use_webhook=use_webhook,
                                                                             interaction_id=interaction_id,
                                                                             token=interaction_token,
                                                                             application_id=application_id,
-                                                                            deffered=deffered,
-                                                                            fields=payload)
+                                                                            deffered=deffered, **fields)
                 except NotFound:
+                    is_interaction_responce = None
                     raise UnknowInteraction(application_id)
+                else:
+                    [self.__setattr__(k, v) for k, v in fields.items()]
 
         elif is_interaction_responce is None:
             payload = await self._state.http.edit_message(self.channel.id, self.id, **fields)

discord/raw_models.py

@@ -266,7 +266,7 @@ def __init__(self, data, http=None):
         self.message: Message = None
         self._deferred = False
 
-    async def defer(self):
+    async def defer(self, ):
         """
         'Defers' the response, showing a loading state to the user
         """
@@ -286,13 +286,8 @@ async def edit(self, **fields):
         """
         if not self.message:
             self.message: Message = await self.channel.fetch_message(self._message_id)
-
-        try:
-            await self.message.edit(__is_interaction_responce=True, __deffered=self.deffered, __use_webhook=False, __interaction_id=self.__interaction_id, __interaction_token=self.__token, __application_id=self.__application_id, **fields)
-        except NotFound:
-            pass
-        else:
-            self._deferred = True
+        await self.message.edit(__is_interaction_responce=True, __deffered=self.deffered, __use_webhook=False, __interaction_id=self.__interaction_id, __interaction_token=self.__token, __application_id=self.__application_id, **fields)
+        self._deferred = True
 
     @property
     def deffered(self):