refactor!: another bulk of changes

I need to make more commits

Author: VincentRPS

discord/app/cache.py

@@ -211,15 +211,15 @@ async def get_user(self, user_id: int) -> User:
     async def get_all_stickers(self) -> list[GuildSticker]:
         return list(self._stickers.values())
 
-    async def get_sticker(self, sticker_id: int) -> GuildSticker:
+    async def get_sticker(self, sticker_id: int) -> GuildSticker | None:
         return self._stickers.get(sticker_id)
 
     async def store_sticker(self, guild: Guild, data: GuildStickerPayload) -> GuildSticker:
         sticker = GuildSticker(state=self._state, data=data)
         try:
             self._stickers[guild.id].append(sticker)
         except KeyError:
-            self._stickers[guild.id] = sticker
+            self._stickers[guild.id] = [sticker]
         return sticker
 
     async def delete_sticker(self, sticker_id: int) -> None:
@@ -228,10 +228,12 @@ async def delete_sticker(self, sticker_id: int) -> None:
     # interactions
 
     async def delete_view_on(self, message_id: int) -> View | None:
-        return self._views.pop(message_id, None)
+        for view in await self.get_all_views():
+            if view.message and view.message.id == message_id:
+                return view
 
     async def store_view(self, view: View, message_id: int) -> None:
-        self._views[message_id or view.id] = view
+        self._views[str(message_id or view.id)] = view
 
     async def get_all_views(self) -> list[View]:
         return list(self._views.values())

discord/app/events.py renamed to discord/app/event_emitter.py

@@ -29,14 +29,14 @@
 
 from .state import ConnectionState
 
-T = TypeVar('T')
+T = TypeVar('T', bound='Event')
 
 
 class Event(ABC):
     __event_name__: str
 
     @classmethod
-    async def __load__(cls, data: dict[str, Any], state: ConnectionState) -> Self:
+    async def __load__(cls, data: Any, state: ConnectionState) -> Self | None:
         ...
 
 
@@ -61,7 +61,7 @@ def add_listener(self, event: Type[Event], listener: Callable) -> None:
             self._listeners[event].append(listener)
         except KeyError:
             self.add_event(event)
-            self._listener[event] = [listener]
+            self._listeners[event] = [listener]
 
     def remove_listener(self, event: Type[Event], listener: Callable) -> None:
         self._listeners[event].remove(listener)
@@ -79,21 +79,23 @@ def add_wait_for(self, event: Type[T]) -> Future[T]:
     def remove_wait_for(self, event: Type[Event], fut: Future) -> None:
         self._wait_fors[event].remove(fut)
 
-    async def publish(self, event_str: str, data: dict[str, Any]) -> None:
-        items = list(self.events.items())
+    async def emit(self, event_str: str, data: Any) -> None:
+        events = self._events.get(event_str, [])
 
-        for event, funcs in items:
-            if event._name == event_str:
-                eve = event()
+        for event in events:
+            eve = await event.__load__(data=data, state=self._state)
 
-                await eve.__load__(data)
+            if eve is None:
+                continue
 
-                for func in funcs:
-                    asyncio.create_task(func(eve))
+            funcs = self._listeners.get(event, [])
 
-                wait_fors = self.wait_fors.get(event)
+            for func in funcs:
+                asyncio.create_task(func(eve))
 
-                if wait_fors is not None:
-                    for wait_for in wait_fors:
-                        wait_for.set_result(eve)
-                    self.wait_fors.pop(event)
+            wait_fors = self._wait_fors.get(event)
+
+            if wait_fors is not None:
+                for wait_for in wait_fors:
+                    wait_for.set_result(eve)
+                self._wait_fors.pop(event)

discord/app/state.py

@@ -43,6 +43,8 @@
     Union,
 )
 
+from discord.app.event_emitter import EventEmitter
+
 from .cache import Cache
 
 from .. import utils
@@ -186,6 +188,7 @@ def __init__(
         self.application_id: int | None = utils._get_as_snowflake(
             options, "application_id"
         )
+        self.application_flags: ApplicationFlags | None = None
         self.heartbeat_timeout: float = options.get("heartbeat_timeout", 60.0)
         self.guild_ready_timeout: float = options.get("guild_ready_timeout", 2.0)
         if self.guild_ready_timeout < 0:
@@ -256,10 +259,7 @@ def __init__(
 
         self.cache_app_emojis: bool = options.get("cache_app_emojis", False)
 
-        self.parsers = parsers = {}
-        for attr, func in inspect.getmembers(self):
-            if attr.startswith("parse_"):
-                parsers[attr[6:].upper()] = func
+        self.emitter = EventEmitter(self)
 
         self.cache: Cache = self.cache
 
@@ -268,13 +268,13 @@ def clear(self, *, views: bool = True) -> None:
         self.cache.clear()
         self._voice_clients: dict[int, VoiceClient] = {}
 
-    def process_chunk_requests(
+    async def process_chunk_requests(
         self, guild_id: int, nonce: str | None, members: list[Member], complete: bool
     ) -> None:
         removed = []
         for key, request in self._chunk_requests.items():
             if request.guild_id == guild_id and request.nonce == nonce:
-                request.add_members(members)
+                await request.add_members(members)
                 if complete:
                     request.done()
                     removed.append(key)
@@ -524,175 +524,6 @@ async def query_members(
             )
             raise
 
-    async def _delay_ready(self) -> None:
-
-        if self.cache_app_emojis and self.application_id:
-            data = await self.http.get_all_application_emojis(self.application_id)
-            for e in data.get("items", []):
-                await self.maybe_store_app_emoji(self.application_id, e)
-        try:
-            states = []
-            while True:
-                # this snippet of code is basically waiting N seconds
-                # until the last GUILD_CREATE was sent
-                try:
-                    guild = await asyncio.wait_for(
-                        self._ready_state.get(), timeout=self.guild_ready_timeout
-                    )
-                except asyncio.TimeoutError:
-                    break
-                else:
-                    if self._guild_needs_chunking(guild):
-                        future = await self.chunk_guild(guild, wait=False)
-                        states.append((guild, future))
-                    elif guild.unavailable is False:
-                        self.dispatch("guild_available", guild)
-                    else:
-                        self.dispatch("guild_join", guild)
-
-            for guild, future in states:
-                try:
-                    await asyncio.wait_for(future, timeout=5.0)
-                except asyncio.TimeoutError:
-                    _log.warning(
-                        "Shard ID %s timed out waiting for chunks for guild_id %s.",
-                        guild.shard_id,
-                        guild.id,
-                    )
-
-                if guild.unavailable is False:
-                    self.dispatch("guild_available", guild)
-                else:
-                    self.dispatch("guild_join", guild)
-
-            # remove the state
-            try:
-                del self._ready_state
-            except AttributeError:
-                pass  # already been deleted somehow
-
-        except asyncio.CancelledError:
-            pass
-        else:
-            # dispatch the event
-            self.call_handlers("ready")
-            self.dispatch("ready")
-        finally:
-            self._ready_task = None
-
-    def parse_ready(self, data) -> None:
-        if self._ready_task is not None:
-            self._ready_task.cancel()
-
-        self._ready_state = asyncio.Queue()
-        self.clear(views=False)
-        self.user = ClientUser(state=self, data=data["user"])
-        self.store_user(data["user"])
-
-        if self.application_id is None:
-            try:
-                application = data["application"]
-            except KeyError:
-                pass
-            else:
-                self.application_id = utils._get_as_snowflake(application, "id")
-                # flags will always be present here
-                self.application_flags = ApplicationFlags._from_value(application["flags"])  # type: ignore
-
-        for guild_data in data["guilds"]:
-            self._add_guild_from_data(guild_data)
-
-        self.dispatch("connect")
-        self._ready_task = asyncio.create_task(self._delay_ready())
-
-    def parse_resumed(self, data) -> None:
-        self.dispatch("resumed")
-
-    def parse_application_command_permissions_update(self, data) -> None:
-        # unsure what the implementation would be like
-        pass
-
-    def parse_auto_moderation_rule_create(self, data) -> None:
-        rule = AutoModRule(state=self, data=data)
-        self.dispatch("auto_moderation_rule_create", rule)
-
-    def parse_auto_moderation_rule_update(self, data) -> None:
-        # somehow get a 'before' object?
-        rule = AutoModRule(state=self, data=data)
-        self.dispatch("auto_moderation_rule_update", rule)
-
-    def parse_auto_moderation_rule_delete(self, data) -> None:
-        rule = AutoModRule(state=self, data=data)
-        self.dispatch("auto_moderation_rule_delete", rule)
-
-    def parse_auto_moderation_action_execution(self, data) -> None:
-        event = AutoModActionExecutionEvent(self, data)
-        self.dispatch("auto_moderation_action_execution", event)
-
-    def parse_entitlement_create(self, data) -> None:
-        event = Entitlement(data=data, state=self)
-        self.dispatch("entitlement_create", event)
-
-    def parse_entitlement_update(self, data) -> None:
-        event = Entitlement(data=data, state=self)
-        self.dispatch("entitlement_update", event)
-
-    def parse_entitlement_delete(self, data) -> None:
-        event = Entitlement(data=data, state=self)
-        self.dispatch("entitlement_delete", event)
-
-    def parse_subscription_create(self, data) -> None:
-        event = Subscription(data=data, state=self)
-        self.dispatch("subscription_create", event)
-
-    def parse_subscription_update(self, data) -> None:
-        event = Subscription(data=data, state=self)
-        self.dispatch("subscription_update", event)
-
-    def parse_subscription_delete(self, data) -> None:
-        event = Subscription(data=data, state=self)
-        self.dispatch("subscription_delete", event)
-
-    def parse_message_create(self, data) -> None:
-        channel, _ = self._get_guild_channel(data)
-        # channel would be the correct type here
-        message = Message(channel=channel, data=data, state=self)  # type: ignore
-        self.dispatch("message", message)
-        if self._messages is not None:
-            self._messages.append(message)
-        # we ensure that the channel is either a TextChannel, VoiceChannel, StageChannel, or Thread
-        if channel and channel.__class__ in (
-            TextChannel,
-            VoiceChannel,
-            StageChannel,
-            Thread,
-        ):
-            channel.last_message_id = message.id  # type: ignore
-
-    def parse_message_delete(self, data) -> None:
-        raw = RawMessageDeleteEvent(data)
-        found = self._get_message(raw.message_id)
-        raw.cached_message = found
-        self.dispatch("raw_message_delete", raw)
-        if self._messages is not None and found is not None:
-            self.dispatch("message_delete", found)
-            self._messages.remove(found)
-
-    def parse_message_delete_bulk(self, data) -> None:
-        raw = RawBulkMessageDeleteEvent(data)
-        if self._messages:
-            found_messages = [
-                message for message in self._messages if message.id in raw.message_ids
-            ]
-        else:
-            found_messages = []
-        raw.cached_messages = found_messages
-        self.dispatch("raw_bulk_message_delete", raw)
-        if found_messages:
-            self.dispatch("bulk_message_delete", found_messages)
-            for msg in found_messages:
-                # self._messages won't be None here
-                self._messages.remove(msg)  # type: ignore
 
     def parse_message_update(self, data) -> None:
         raw = RawMessageUpdateEvent(data)

discord/client.py

@@ -879,10 +879,9 @@ def intents(self) -> Intents:
 
     # helpers/getters
 
-    @property
-    def users(self) -> list[User]:
+    async def get_users(self) -> list[User]:
         """Returns a list of all the users the bot can see."""
-        return list(self._connection._users.values())
+        return await self._connection.cache.get_all_users()
 
     async def fetch_application(self, application_id: int, /) -> PartialAppInfo:
         """|coro|

discord/commands/core.py

@@ -991,7 +991,7 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
                         # We resolved the user from the user id
                         _data["user"] = _user_data
                     cache_flag = ctx.interaction._state.member_cache_flags.interaction
-                    arg = ctx.guild._get_and_update_member(_data, int(arg), cache_flag)
+                    arg = await ctx.guild._get_and_update_member(_data, int(arg), cache_flag)
                 elif op.input_type is SlashCommandOptionType.mentionable:
                     if (_data := resolved.get("users", {}).get(arg)) is not None:
                         arg = User(state=ctx.interaction._state, data=_data)
@@ -1787,7 +1787,7 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
                 user = v
             member["user"] = user
             cache_flag = ctx.interaction._state.member_cache_flags.interaction
-            target = ctx.guild._get_and_update_member(member, user["id"], cache_flag)
+            target = await ctx.guild._get_and_update_member(member, user["id"], cache_flag)
         if self.cog is not None:
             await self.callback(self.cog, ctx, target)
         else:

discord/enums.py

@@ -76,6 +76,7 @@
     "EntitlementOwnerType",
     "IntegrationType",
     "InteractionContextType",
+    "ApplicationCommandPermissionType"
 )
 
 
@@ -1063,6 +1064,14 @@ class SubscriptionStatus(Enum):
     inactive = 2
 
 
+class ApplicationCommandPermissionType(Enum):
+    """The type of permission"""
+
+    role = 1
+    user = 2
+    channel = 3
+
+
 T = TypeVar("T")