fix: various fixes for contexts (#856)

* fix: use _client instead of client for ctx

client is still available for backwards-compat purposes

* fix: don't make msg for ctx a dict

* fix: client > _client

* refactor: rename inconsistent client

* fix: actually typehint log

Author: AstreaTSS

interactions/api/gateway/client.py

@@ -417,7 +417,7 @@ def __contextualize(self, data: dict) -> object:
             elif data["type"] == InteractionType.MESSAGE_COMPONENT:
                 _context = "ComponentContext"
 
-            data["client"] = self._http
+            data["_client"] = self._http
             context: object = getattr(__import__("interactions.client.context"), _context)
 
             return context(**data)

interactions/client/context.py

@@ -2,7 +2,8 @@
 from typing import List, Optional, Union
 
 from ..api.error import LibraryException
-from ..api.models.attrs_utils import MISSING, DictSerializerMixin, define, field
+from ..api.http.client import HTTPClient
+from ..api.models.attrs_utils import MISSING, ClientSerializerMixin, define, field
 from ..api.models.channel import Channel
 from ..api.models.guild import Guild
 from ..api.models.member import Member
@@ -25,7 +26,7 @@
 
 
 @define()
-class _Context(DictSerializerMixin):
+class _Context(ClientSerializerMixin):
     """
     The base class of "context" for dispatched event data
     from the gateway. The premise of having this class is so
@@ -40,7 +41,7 @@ class _Context(DictSerializerMixin):
     :ivar Optional[Guild] guild: The guild data model.
     """
 
-    client = field()
+    client: HTTPClient = field(default=None)
     message: Optional[Message] = field(converter=Message, default=None, add_client=True)
     author: Member = field(converter=Member, default=None, add_client=True)
     member: Member = field(converter=Member, add_client=True)
@@ -62,16 +63,18 @@ class _Context(DictSerializerMixin):
     deferred: bool = field(default=False)
 
     def __attrs_post_init__(self) -> None:
+        # backwards compatibility
+        self.client = self._client
         self.author = self.member
 
         if self.user is None:
             self.user = self.member.user if self.member else None
 
         if self.guild is None and self.guild_id is not None:
-            self.guild = self.client.cache.guilds.values.get(self.guild_id, MISSING)
+            self.guild = self._client.cache.guilds.values.get(self.guild_id, MISSING)
 
         if self.channel is None:
-            self.channel = self.client.cache.channels.values.get(self.channel_id, MISSING)
+            self.channel = self._client.cache.channels.values.get(self.channel_id, MISSING)
 
     async def get_channel(self) -> Channel:
         """
@@ -81,8 +84,8 @@ async def get_channel(self) -> Channel:
         :rtype: Channel
         """
 
-        res = await self.client.get_channel(int(self.channel_id))
-        self.channel = Channel(**res, _client=self.client)
+        res = await self._client.get_channel(int(self.channel_id))
+        self.channel = Channel(**res, _client=self._client)
         return self.channel
 
     async def get_guild(self) -> Guild:
@@ -93,8 +96,8 @@ async def get_guild(self) -> Guild:
         :rtype: Guild
         """
 
-        res = await self.client.get_guild(int(self.guild_id))
-        self.guild = Guild(**res, _client=self.client)
+        res = await self._client.get_guild(int(self.guild_id))
+        self.guild = Guild(**res, _client=self._client)
         return self.guild
 
     async def send(
@@ -266,7 +269,7 @@ async def popup(self, modal: Modal) -> None:
             },
         }
 
-        await self.client.create_interaction_response(
+        await self._client.create_interaction_response(
             token=self.token,
             application_id=int(self.id),
             data=payload,
@@ -333,39 +336,39 @@ async def edit(self, content: Optional[str] = MISSING, **kwargs) -> Message:
 
         if self.deferred:
             if hasattr(self.message, "id") and self.message.id is not None:
-                res = await self.client.edit_message(
+                res = await self._client.edit_message(
                     int(self.channel_id), int(self.message.id), payload=payload
                 )
-                self.message = msg = Message(**res, _client=self.client)
+                self.message = msg = Message(**res, _client=self._client)
             else:
-                res = await self.client.edit_interaction_response(
+                res = await self._client.edit_interaction_response(
                     token=self.token,
                     application_id=str(self.id),
                     data={"type": self.callback.value, "data": payload},
                     message_id=self.message.id if self.message else "@original",
                 )
                 if res["flags"] == 64:
                     log.warning("You can't edit hidden messages.")
-                    self.message = payload
-                    self.message._client = self.client
                 else:
-                    await self.client.edit_message(int(self.channel_id), res["id"], payload=payload)
-                    self.message = msg = Message(**res, _client=self.client)
+                    await self._client.edit_message(
+                        int(self.channel_id), res["id"], payload=payload
+                    )
+                    self.message = msg = Message(**res, _client=self._client)
         else:
-            res = await self.client.edit_interaction_response(
+            res = await self._client.edit_interaction_response(
                 token=self.token,
                 application_id=str(self.application_id),
                 data={"type": self.callback.value, "data": payload},
             )
             if res["flags"] == 64:
                 log.warning("You can't edit hidden messages.")
             else:
-                await self.client.edit_message(int(self.channel_id), res["id"], payload=payload)
-                self.message = msg = Message(**res, _client=self.client)
+                await self._client.edit_message(int(self.channel_id), res["id"], payload=payload)
+                self.message = msg = Message(**res, _client=self._client)
 
         if msg is not None:
             return msg
-        return Message(**payload, _client=self.client)
+        return Message(**payload, _client=self._client)
 
     async def defer(self, ephemeral: Optional[bool] = False) -> None:
         """
@@ -379,7 +382,7 @@ async def defer(self, ephemeral: Optional[bool] = False) -> None:
         _ephemeral: int = (1 << 6) if ephemeral else 0
         self.callback = InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
 
-        await self.client.create_interaction_response(
+        await self._client.create_interaction_response(
             token=self.token,
             application_id=int(self.id),
             data={"type": self.callback.value, "data": {"flags": _ephemeral}},
@@ -396,42 +399,42 @@ async def send(self, content: Optional[str] = MISSING, **kwargs) -> Message:
         msg = None
         if self.responded or self.deferred:
             if self.deferred:
-                res = await self.client.edit_interaction_response(
+                res = await self._client.edit_interaction_response(
                     data=payload,
                     token=self.token,
                     application_id=str(self.application_id),
                 )
                 self.responded = True
             else:
-                res = await self.client._post_followup(
+                res = await self._client._post_followup(
                     data=payload,
                     token=self.token,
                     application_id=str(self.application_id),
                 )
-            self.message = msg = Message(**res, _client=self.client)
+            self.message = msg = Message(**res, _client=self._client)
         else:
-            await self.client.create_interaction_response(
+            await self._client.create_interaction_response(
                 token=self.token,
                 application_id=int(self.id),
                 data=_payload,
             )
-            __newdata = await self.client.edit_interaction_response(
+            __newdata = await self._client.edit_interaction_response(
                 data={},
                 token=self.token,
                 application_id=str(self.application_id),
             )
             if not __newdata.get("code"):
                 # if sending message fails somehow
-                msg = Message(**__newdata, _client=self.client)
+                msg = Message(**__newdata, _client=self._client)
                 self.message = msg
             self.responded = True
         if msg is not None:
             return msg
 
         return Message(
             **payload,
-            _client=self.client,
-            author={"client": self.client, "id": None, "username": None, "discriminator": None},
+            _client=self._client,
+            author={"_client": self._client, "id": None, "username": None, "discriminator": None},
         )
 
     async def delete(self) -> None:
@@ -444,11 +447,11 @@ async def delete(self) -> None:
             being present.
         """
         if self.responded:
-            await self.client.delete_webhook_message(
+            await self._client.delete_webhook_message(
                 webhook_id=int(self.id), webhook_token=self.token, message_id=int(self.message.id)
             )
         else:
-            await self.client.delete_original_webhook_message(int(self.id), self.token)
+            await self._client.delete_original_webhook_message(int(self.id), self.token)
         self.message = None
 
     async def populate(self, choices: Union[Choice, List[Choice]]) -> List[Choice]:
@@ -487,7 +490,7 @@ async def func():
                     6, message="Autocomplete choice items must be of type Choice"
                 )
 
-            await self.client.create_interaction_response(
+            await self._client.create_interaction_response(
                 token=self.token,
                 application_id=int(self.id),
                 data={
@@ -514,31 +517,31 @@ async def edit(self, content: Optional[str] = MISSING, **kwargs) -> Message:
 
         if not self.deferred:
             self.callback = InteractionCallbackType.UPDATE_MESSAGE
-            await self.client.create_interaction_response(
+            await self._client.create_interaction_response(
                 data={"type": self.callback.value, "data": payload},
                 token=self.token,
                 application_id=int(self.id),
             )
             # self.message = payload
             self.responded = True
         elif self.callback != InteractionCallbackType.DEFERRED_UPDATE_MESSAGE:
-            res = await self.client._post_followup(
+            res = await self._client._post_followup(
                 data=payload,
                 token=self.token,
                 application_id=str(self.application_id),
             )
-            self.message = Message(**res, _client=self.client)
+            self.message = Message(**res, _client=self._client)
         else:
-            res = await self.client.edit_interaction_response(
+            res = await self._client.edit_interaction_response(
                 data=payload,
                 token=self.token,
                 application_id=str(self.application_id),
             )
             self.responded = True
-            self.message = Message(**res, _client=self.client)
+            self.message = Message(**res, _client=self._client)
 
         if self.message is None:
-            self.message = Message(**payload, _client=self.client)
+            self.message = Message(**payload, _client=self._client)
 
         return self.message
 
@@ -557,34 +560,34 @@ async def send(self, content: Optional[str] = MISSING, **kwargs) -> Message:
             or self.callback == InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
         ):
             if self.deferred:
-                res = await self.client.edit_interaction_response(
+                res = await self._client.edit_interaction_response(
                     data=payload,
                     token=self.token,
                     application_id=str(self.application_id),
                 )
                 self.responded = True
             else:
-                res = await self.client._post_followup(
+                res = await self._client._post_followup(
                     data=payload,
                     token=self.token,
                     application_id=str(self.application_id),
                 )
-            self.message = msg = Message(**res, _client=self.client)
+            self.message = msg = Message(**res, _client=self._client)
 
         else:
-            await self.client.create_interaction_response(
+            await self._client.create_interaction_response(
                 token=self.token,
                 application_id=int(self.id),
                 data=_payload,
             )
-            __newdata = await self.client.edit_interaction_response(
+            __newdata = await self._client.edit_interaction_response(
                 data={},
                 token=self.token,
                 application_id=str(self.application_id),
             )
             if not __newdata.get("code"):
                 # if sending message fails somehow
-                msg = Message(**__newdata, _client=self.client)
+                msg = Message(**__newdata, _client=self._client)
                 self.message = msg
             self.responded = True
 
@@ -613,7 +616,7 @@ async def defer(
         else:
             self.callback = InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
 
-        await self.client.create_interaction_response(
+        await self._client.create_interaction_response(
             token=self.token,
             application_id=int(self.id),
             data={"type": self.callback.value, "data": {"flags": _ephemeral}},

interactions/client/context.pyi

@@ -1,7 +1,8 @@
+from logging import Logger
 from typing import Any, List, Optional, Union
 
 from ..api.http.client import HTTPClient
-from ..api.models.attrs_utils import DictSerializerMixin, define
+from ..api.models.attrs_utils import ClientSerializerMixin, define
 from ..api.models.channel import Channel as Channel
 from ..api.models.guild import Guild as Guild
 from ..api.models.member import Member as Member
@@ -23,7 +24,7 @@ from .models.misc import InteractionData as InteractionData
 log: Logger
 
 @define()
-class _Context(DictSerializerMixin):
+class _Context(ClientSerializerMixin):
     client: HTTPClient
     message: Optional[Message]
     author: Member