feat: add more events

Author: VincentRPS

discord/abc.py

@@ -629,8 +629,7 @@ def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:
 
         return PermissionOverwrite()
 
-    @property
-    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:
+    async def get_overwrites(self) -> dict[Role | Member, PermissionOverwrite]:
         """Returns all of the channel's overwrites.
 
         This is returned as a dictionary where the key contains the target which
@@ -652,7 +651,7 @@ def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:
             if ow.is_role():
                 target = self.guild.get_role(ow.id)
             elif ow.is_member():
-                target = self.guild.get_member(ow.id)
+                target = await self.guild.get_member(ow.id)
 
             # TODO: There is potential data loss here in the non-chunked
             # case, i.e. target is None because get_member returned nothing.

discord/app/cache.py

@@ -22,11 +22,12 @@
 DEALINGS IN THE SOFTWARE.
 """
 
-from collections import OrderedDict, deque
-from typing import Deque, Protocol
+from collections import OrderedDict, defaultdict, deque
+from typing import Deque, Protocol, TypeVar
 
 from discord import utils
 from discord.app.state import ConnectionState
+from discord.member import Member
 from discord.message import Message
 
 from ..abc import MessageableChannel, PrivateChannel
@@ -44,6 +45,8 @@
 from ..types.channel import DMChannel as DMChannelPayload
 from ..types.message import Message as MessagePayload
 
+T = TypeVar('T')
+
 class Cache(Protocol):
     # users
     async def get_all_users(self) -> list[User]:
@@ -167,6 +170,26 @@ async def get_message(self, message_id: int) -> Message | None:
     async def get_all_messages(self) -> list[Message]:
         ...
 
+    # guild members
+
+    async def store_member(self, member: Member) -> None:
+        ...
+
+    async def get_member(self, guild_id: int, user_id: int) -> Member | None:
+        ...
+
+    async def delete_member(self, guild_id: int, user_id: int) -> None:
+        ...
+
+    async def delete_guild_members(self, guild_id: int) -> None:
+        ...
+
+    async def get_guild_members(self, guild_id: int) -> list[Member]:
+        ...
+
+    async def get_all_members(self) -> list[Member]:
+        ...
+
     def clear(self, views: bool = True) -> None:
         ...
 
@@ -176,6 +199,9 @@ def __init__(self, max_messages: int | None = None, *, state: ConnectionState):
         self.max_messages = max_messages
         self.clear()
 
+    def _flatten(self, matrix: list[list[T]]) -> list[T]:
+        return [item for row in matrix for item in row]
+
     def clear(self, views: bool = True) -> None:
         self._users: dict[int, User] = {}
         self._guilds: dict[int, Guild] = {}
@@ -186,11 +212,13 @@ def clear(self, views: bool = True) -> None:
         self._modals: dict[str, Modal] = {}
         self._messages: Deque[Message] = deque(maxlen=self.max_messages)
 
-        self._emojis = dict[str, GuildEmoji | AppEmoji] = {}
+        self._emojis: dict[int, list[GuildEmoji | AppEmoji]] = {}
 
         self._private_channels: OrderedDict[int, PrivateChannel] = OrderedDict()
         self._private_channels_by_user: dict[int, DMChannel] = {}
 
+        self._guild_members: dict[int, dict[int, Member]] = defaultdict(dict)
+
     # users
     async def get_all_users(self) -> list[User]:
         return list(self._users.values())
@@ -200,7 +228,7 @@ async def store_user(self, payload: UserPayload) -> User:
         try:
             return self._users[user_id]
         except KeyError:
-            user = User(state=self, data=payload)
+            user = User(state=self._state, data=payload)
             if user.discriminator != "0000":
                 self._users[user_id] = user
                 user._stored = True
@@ -209,16 +237,19 @@ async def store_user(self, payload: UserPayload) -> User:
     async def delete_user(self, user_id: int) -> None:
         self._users.pop(user_id, None)
 
-    async def get_user(self, user_id: int) -> User:
+    async def get_user(self, user_id: int) -> User | None:
         return self._users.get(user_id)
 
     # stickers
 
     async def get_all_stickers(self) -> list[GuildSticker]:
-        return list(self._stickers.values())
+        return self._flatten(list(self._stickers.values()))
 
     async def get_sticker(self, sticker_id: int) -> GuildSticker | None:
-        return self._stickers.get(sticker_id)
+        stickers = self._flatten(list(self._stickers.values()))
+        for sticker in stickers:
+            if sticker.id == sticker_id:
+                return sticker
 
     async def store_sticker(self, guild: Guild, data: GuildStickerPayload) -> GuildSticker:
         sticker = GuildSticker(state=self._state, data=data)
@@ -285,10 +316,13 @@ async def store_app_emoji(
         return emoji
 
     async def get_all_emojis(self) -> list[GuildEmoji | AppEmoji]:
-        return list(self._emojis.values())
+        return self._flatten(list(self._emojis.values()))
 
     async def get_emoji(self, emoji_id: int | None) -> GuildEmoji | AppEmoji | None:
-        return self._emojis.get(emoji_id)
+        emojis = self._flatten(list(self._emojis.values()))
+        for emoji in emojis:
+            if emoji.id == emoji_id:
+                return emoji
 
     async def delete_emoji(self, emoji: GuildEmoji | AppEmoji) -> None:
         if isinstance(emoji, AppEmoji):
@@ -354,3 +388,23 @@ async def get_all_messages(self) -> list[Message]:
 
     async def delete_modal(self, custom_id: str) -> None:
         self._modals.pop(custom_id, None)
+
+    # guild members
+
+    async def store_member(self, member: Member) -> None:
+        self._guild_members[member.guild.id][member.id] = member
+
+    async def get_member(self, guild_id: int, user_id: int) -> Member | None:
+        return self._guild_members[guild_id].get(user_id)
+
+    async def delete_member(self, guild_id: int, user_id: int) -> None:
+        self._guild_members[guild_id].pop(user_id, None)
+
+    async def delete_guild_members(self, guild_id: int) -> None:
+        self._guild_members.pop(guild_id, None)
+
+    async def get_guild_members(self, guild_id: int) -> list[Member]:
+        return list(self._guild_members.get(guild_id, {}).values())
+
+    async def get_all_members(self) -> list[Member]:
+        return self._flatten([list(members.values()) for members in self._guild_members.values()])

discord/app/state.py

@@ -126,9 +126,9 @@ async def add_members(self, members: list[Member]) -> None:
                 return
 
             for member in members:
-                existing = guild.get_member(member.id)
+                existing = await guild.get_member(member.id)
                 if existing is None or existing.joined_at is None:
-                    guild._add_member(member)
+                    await guild._add_member(member)
 
     async def wait(self) -> list[Member]:
         future = self.loop.create_future()
@@ -524,174 +524,6 @@ async def query_members(
             )
             raise
 
-    def parse_presence_update(self, data) -> None:
-        guild_id = utils._get_as_snowflake(data, "guild_id")
-        # guild_id won't be None here
-        guild = self._get_guild(guild_id)
-        if guild is None:
-            _log.debug(
-                "PRESENCE_UPDATE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-            return
-
-        user = data["user"]
-        member_id = int(user["id"])
-        member = guild.get_member(member_id)
-        if member is None:
-            _log.debug(
-                "PRESENCE_UPDATE referencing an unknown member ID: %s. Discarding",
-                member_id,
-            )
-            return
-
-        old_member = Member._copy(member)
-        user_update = member._presence_update(data=data, user=user)
-        if user_update:
-            self.dispatch("user_update", user_update[0], user_update[1])
-
-        self.dispatch("presence_update", old_member, member)
-
-    def parse_user_update(self, data) -> None:
-        # self.user is *always* cached when this is called
-        user: ClientUser = self.user  # type: ignore
-        user._update(data)
-        ref = self._users.get(user.id)
-        if ref:
-            ref._update(data)
-
-    def parse_invite_create(self, data) -> None:
-        invite = Invite.from_gateway(state=self, data=data)
-        self.dispatch("invite_create", invite)
-
-    def parse_invite_delete(self, data) -> None:
-        invite = Invite.from_gateway(state=self, data=data)
-        self.dispatch("invite_delete", invite)
-
-    def parse_channel_delete(self, data) -> None:
-        guild = self._get_guild(utils._get_as_snowflake(data, "guild_id"))
-        channel_id = int(data["id"])
-        if guild is not None:
-            channel = guild.get_channel(channel_id)
-            if channel is not None:
-                guild._remove_channel(channel)
-                self.dispatch("guild_channel_delete", channel)
-
-    def parse_channel_update(self, data) -> None:
-        channel_type = try_enum(ChannelType, data.get("type"))
-        channel_id = int(data["id"])
-        if channel_type is ChannelType.group:
-            channel = self._get_private_channel(channel_id)
-            old_channel = copy.copy(channel)
-            # the channel is a GroupChannel
-            channel._update_group(data)  # type: ignore
-            self.dispatch("private_channel_update", old_channel, channel)
-            return
-
-        guild_id = utils._get_as_snowflake(data, "guild_id")
-        guild = self._get_guild(guild_id)
-        if guild is not None:
-            channel = guild.get_channel(channel_id)
-            if channel is not None:
-                old_channel = copy.copy(channel)
-                channel._update(guild, data)
-                self.dispatch("guild_channel_update", old_channel, channel)
-            else:
-                _log.debug(
-                    "CHANNEL_UPDATE referencing an unknown channel ID: %s. Discarding.",
-                    channel_id,
-                )
-        else:
-            _log.debug(
-                "CHANNEL_UPDATE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-
-    def parse_channel_create(self, data) -> None:
-        factory, ch_type = _channel_factory(data["type"])
-        if factory is None:
-            _log.debug(
-                "CHANNEL_CREATE referencing an unknown channel type %s. Discarding.",
-                data["type"],
-            )
-            return
-
-        guild_id = utils._get_as_snowflake(data, "guild_id")
-        guild = self._get_guild(guild_id)
-        if guild is not None:
-            # the factory can't be a DMChannel or GroupChannel here
-            channel = factory(guild=guild, state=self, data=data)  # type: ignore
-            guild._add_channel(channel)  # type: ignore
-            self.dispatch("guild_channel_create", channel)
-        else:
-            _log.debug(
-                "CHANNEL_CREATE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-            return
-
-    def parse_channel_pins_update(self, data) -> None:
-        channel_id = int(data["channel_id"])
-        try:
-            guild = self._get_guild(int(data["guild_id"]))
-        except KeyError:
-            guild = None
-            channel = self._get_private_channel(channel_id)
-        else:
-            channel = guild and guild._resolve_channel(channel_id)
-
-        if channel is None:
-            _log.debug(
-                (
-                    "CHANNEL_PINS_UPDATE referencing an unknown channel ID: %s."
-                    " Discarding."
-                ),
-                channel_id,
-            )
-            return
-
-        last_pin = (
-            utils.parse_time(data["last_pin_timestamp"])
-            if data["last_pin_timestamp"]
-            else None
-        )
-
-        if guild is None:
-            self.dispatch("private_channel_pins_update", channel, last_pin)
-        else:
-            self.dispatch("guild_channel_pins_update", channel, last_pin)
-
-    def parse_thread_create(self, data) -> None:
-        guild_id = int(data["guild_id"])
-        guild: Guild | None = self._get_guild(guild_id)
-        if guild is None:
-            _log.debug(
-                "THREAD_CREATE referencing an unknown guild ID: %s. Discarding",
-                guild_id,
-            )
-            return
-
-        cached_thread = guild.get_thread(int(data["id"]))
-        if not cached_thread:
-            thread = Thread(guild=guild, state=guild._state, data=data)
-            guild._add_thread(thread)
-            if data.get("newly_created"):
-                thread._add_member(
-                    ThreadMember(
-                        thread,
-                        {
-                            "id": thread.id,
-                            "user_id": data["owner_id"],
-                            "join_timestamp": data["thread_metadata"][
-                                "create_timestamp"
-                            ],
-                            "flags": utils.MISSING,
-                        },
-                    )
-                )
-                self.dispatch("thread_create", thread)
-        else:
-            self.dispatch("thread_join", cached_thread)
 
     def parse_thread_update(self, data) -> None:
         guild_id = int(data["guild_id"])
@@ -1541,7 +1373,7 @@ async def _get_reaction_user(
         self, channel: MessageableChannel, user_id: int
     ) -> User | Member | None:
         if isinstance(channel, TextChannel):
-            return channel.guild.get_member(user_id)
+            return await channel.guild.get_member(user_id)
         return await self.get_user(user_id)
 
     async def get_reaction_emoji(self, data) -> GuildEmoji | AppEmoji | PartialEmoji:

discord/audit_logs.py

@@ -603,8 +603,8 @@ def _from_data(self, data: AuditLogEntryPayload) -> None:
         self.user = self._get_member(utils._get_as_snowflake(data, "user_id"))  # type: ignore
         self._target_id = utils._get_as_snowflake(data, "target_id")
 
-    def _get_member(self, user_id: int) -> Member | User | None:
-        return self.guild.get_member(user_id) or self._users.get(user_id)
+    async def _get_member(self, user_id: int) -> Member | User | None:
+        return await self.guild.get_member(user_id) or self._users.get(user_id)
 
     def __repr__(self) -> str:
         return f"<AuditLogEntry id={self.id} action={self.action} user={self.user!r}>"
@@ -667,8 +667,8 @@ def _convert_target_guild(self, target_id: int) -> Guild:
     def _convert_target_channel(self, target_id: int) -> abc.GuildChannel | Object:
         return self.guild.get_channel(target_id) or Object(id=target_id)
 
-    def _convert_target_user(self, target_id: int) -> Member | User | None:
-        return self._get_member(target_id)
+    async def _convert_target_user(self, target_id: int) -> Member | User | None:
+        return await self._get_member(target_id)
 
     def _convert_target_role(self, target_id: int) -> Role | Object:
         return self.guild.get_role(target_id) or Object(id=target_id)
@@ -700,8 +700,8 @@ def _convert_target_invite(self, target_id: int) -> Invite:
     async def _convert_target_emoji(self, target_id: int) -> GuildEmoji | Object:
         return (await self._state.get_emoji(target_id)) or Object(id=target_id)
 
-    def _convert_target_message(self, target_id: int) -> Member | User | None:
-        return self._get_member(target_id)
+    async def _convert_target_message(self, target_id: int) -> Member | User | None:
+        return await self._get_member(target_id)
 
     def _convert_target_stage_instance(self, target_id: int) -> StageInstance | Object:
         return self.guild.get_stage_instance(target_id) or Object(id=target_id)