refactor!: remove View and Model Store & make Guild._from_data into classmethod

Author: VincentRPS

discord/app/cache.py

@@ -35,8 +35,8 @@
 from ..guild import Guild
 from ..poll import Poll
 from ..sticker import GuildSticker, Sticker
-from ..ui.modal import Modal, ModalStore
-from ..ui.view import View, ViewStore
+from ..ui.modal import Modal
+from ..ui.view import View
 from ..user import User
 from ..types.user import User as UserPayload
 from ..types.emoji import Emoji as EmojiPayload

discord/app/state.py

@@ -73,8 +73,8 @@
 from ..stage_instance import StageInstance
 from ..sticker import GuildSticker
 from ..threads import Thread, ThreadMember
-from ..ui.modal import Modal, ModalStore
-from ..ui.view import View, ViewStore
+from ..ui.modal import Modal
+from ..ui.view import View
 from ..user import ClientUser, User
 
 if TYPE_CHECKING:

discord/client.py

@@ -1584,7 +1584,7 @@ async def fetch_guild(self, guild_id: int, /, *, with_counts=True) -> Guild:
             Getting the guild failed.
         """
         data = await self.http.get_guild(guild_id, with_counts=with_counts)
-        return Guild(data=data, state=self._connection)
+        return await Guild._from_data(data=data, state=self._connection)
 
     async def create_guild(
         self,
@@ -1633,7 +1633,7 @@ async def create_guild(
             data = await self.http.create_from_template(code, name, icon_base64)
         else:
             data = await self.http.create_guild(name, icon_base64)
-        return Guild(data=data, state=self._connection)
+        return await Guild._from_data(data=data, state=self._connection)
 
     async def fetch_stage_instance(self, channel_id: int, /) -> StageInstance:
         """|coro|

discord/events/gateway.py

@@ -82,7 +82,7 @@ async def __load__(cls, data: dict[str, Any], state: ConnectionState) -> Self:
         self.guilds = []
 
         for guild_data in data["guilds"]:
-            guild = await Guild(data=guild_data, state=state)._from_data(guild_data)
+            guild = await Guild._from_data(guild_data, state)
             self.guilds.append(guild)
             await state._add_guild(guild)
 
@@ -115,7 +115,7 @@ async def __load__(cls, data: GuildPayload, state: ConnectionState) -> Self:
         self = cls()
         guild = await state._get_guild(int(data["id"]))
         if guild is None:
-            guild = await Guild(data=data, state=state)._from_data(data)
+            guild = await Guild._from_data(data, state)
             await state._add_guild(guild)
         self.guild = guild
         self.__dict__.update(self.guild.__dict__)

discord/guild.py

@@ -298,19 +298,6 @@ class Guild(Hashable):
         3: _GuildLimit(emoji=250, stickers=60, bitrate=384e3, filesize=104_857_600),
     }
 
-    def __init__(self, *, data: GuildPayload, state: ConnectionState):
-        # NOTE:
-        # Adding an attribute here and getting an AttributeError saying
-        # the attr doesn't exist? it has something to do with the order
-        # of the attr in __slots__
-
-        self._channels: dict[int, GuildChannel] = {}
-        self._members: dict[int, Member] = {}
-        self._scheduled_events: dict[int, ScheduledEvent] = {}
-        self._voice_states: dict[int, VoiceState] = {}
-        self._threads: dict[int, Thread] = {}
-        self._state: ConnectionState = state
-
     def _add_channel(self, channel: GuildChannel, /) -> None:
         self._channels[channel.id] = channel
 
@@ -448,7 +435,20 @@ def _remove_role(self, role_id: int, /) -> Role:
 
         return role
 
-    async def _from_data(self, guild: GuildPayload) -> Self:
+    @classmethod
+    async def _from_data(cls, guild: GuildPayload, state: ConnectionState) -> Self:
+        self = cls()
+        # NOTE:
+        # Adding an attribute here and getting an AttributeError saying
+        # the attr doesn't exist? it has something to do with the order
+        # of the attr in __slots__
+
+        self._channels: dict[int, GuildChannel] = {}
+        self._members: dict[int, Member] = {}
+        self._scheduled_events: dict[int, ScheduledEvent] = {}
+        self._voice_states: dict[int, VoiceState] = {}
+        self._threads: dict[int, Thread] = {}
+        self._state: ConnectionState = state
         member_count = guild.get("member_count")
         # Either the payload includes member_count, or it hasn't been set yet.
         # Prevents valid _member_count from suddenly changing to None
@@ -1906,7 +1906,7 @@ async def edit(
             fields["features"] = features
 
         data = await http.edit_guild(self.id, reason=reason, **fields)
-        return Guild(data=data, state=self._state)
+        return Guild._from_data(data=data, state=self._state)
 
     async def fetch_channels(self) -> Sequence[GuildChannel]:
         """|coro|

discord/interactions.py

@@ -235,7 +235,7 @@ async def load_data(self):
         self._guild: Guild | None = None
         self._guild_data = data.get("guild")
         if self.guild is None and self._guild_data:
-            self._guild = Guild(data=self._guild_data, state=self._state)
+            self._guild = await Guild._from_data(data=self._guild_data, state=self._state)
 
         # TODO: there's a potential data loss here
         if self.guild_id:

discord/iterators.py

@@ -638,10 +638,10 @@ def _get_retrieve(self):
         self.retrieve = r
         return r > 0
 
-    def create_guild(self, data):
+    async def create_guild(self, data):
         from .guild import Guild
 
-        return Guild(state=self.state, data=data)
+        return await Guild._from_data(state=self.state, data=data)
 
     async def fill_guilds(self):
         if self._get_retrieve():
@@ -653,7 +653,7 @@ async def fill_guilds(self):
                 data = filter(self._filter, data)
 
             for element in data:
-                await self.guilds.put(self.create_guild(element))
+                await self.guilds.put(await self.create_guild(element))
 
     async def _retrieve_guilds(self, retrieve) -> list[Guild]:
         """Retrieve guilds and update next parameters."""

discord/template.py

@@ -156,7 +156,7 @@ async def from_data(cls, state: ConnectionState, data: TemplatePayload) -> None:
             source_serialised["id"] = guild_id
             state = _PartialTemplateState(state=self._state)
             # Guild expects a ConnectionState, we're passing a _PartialTemplateState
-            self.source_guild = Guild(data=source_serialised, state=state)  # type: ignore
+            self.source_guild = await Guild._from_data(data=source_serialised, state=state)  # type: ignore
         else:
             self.source_guild = guild
 
@@ -200,7 +200,7 @@ async def create_guild(self, name: str, icon: Any = None) -> Guild:
             icon = _bytes_to_base64_data(icon)
 
         data = await self._state.http.create_from_template(self.code, name, icon)
-        return Guild(data=data, state=self._state)
+        return await Guild._from_data(data=data, state=self._state)
 
     async def sync(self) -> Template:
         """|coro|

discord/ui/modal.py

@@ -12,8 +12,7 @@
 from .input_text import InputText
 
 __all__ = (
-    "Modal",
-    "ModalStore",
+    "Modal"
 )
 
 
@@ -69,16 +68,6 @@ def __init__(
         self.__timeout_task: asyncio.Task[None] | None = None
         self.loop = asyncio.get_event_loop()
 
-    def _start_listening_from_store(self, store: ModalStore) -> None:
-        self.__cancel_callback = partial(store.remove_modal)
-        if self.timeout:
-            loop = asyncio.get_running_loop()
-            if self.__timeout_task is not None:
-                self.__timeout_task.cancel()
-
-            self.__timeout_expiry = time.monotonic() + self.timeout
-            self.__timeout_task = loop.create_task(self.__timeout_task_impl())
-
     async def __timeout_task_impl(self) -> None:
         while True:
             # Guard just in case someone changes the value of the timeout at runtime
@@ -305,40 +294,3 @@ def remove_item(self, item: InputText) -> None:
 
     def clear(self) -> None:
         self.weights = [0, 0, 0, 0, 0]
-
-
-class ModalStore:
-    def __init__(self, state: ConnectionState) -> None:
-        # (user_id, custom_id) : Modal
-        self._modals: dict[tuple[int, str], Modal] = {}
-        self._state: ConnectionState = state
-
-    def add_modal(self, modal: Modal, user_id: int):
-        self._modals[(user_id, modal.custom_id)] = modal
-        modal._start_listening_from_store(self)
-
-    def remove_modal(self, modal: Modal, user_id):
-        modal.stop()
-        self._modals.pop((user_id, modal.custom_id))
-
-    async def dispatch(self, user_id: int, custom_id: str, interaction: Interaction):
-        key = (user_id, custom_id)
-        value = self._modals.get(key)
-        if value is None:
-            return
-
-        try:
-            components = [
-                component
-                for parent_component in interaction.data["components"]
-                for component in parent_component["components"]
-            ]
-            for component in components:
-                for child in value.children:
-                    if child.custom_id == component["custom_id"]:  # type: ignore
-                        child.refresh_state(component)
-                        break
-            await value.callback(interaction)
-            self.remove_modal(value, user_id)
-        except Exception as e:
-            return await value.on_error(e, interaction)

discord/ui/view.py

@@ -427,15 +427,6 @@ async def _scheduled_task(self, item: Item, interaction: Interaction):
         except Exception as e:
             return await self.on_error(e, item, interaction)
 
-    def _start_listening_from_store(self, store: ViewStore) -> None:
-        self.__cancel_callback = partial(store.remove_view)
-        if self.timeout:
-            loop = asyncio.get_running_loop()
-            if self.__timeout_task is not None:
-                self.__timeout_task.cancel()
-
-            self.__timeout_expiry = time.monotonic() + self.timeout
-            self.__timeout_task = loop.create_task(self.__timeout_task_impl())
 
     def _dispatch_timeout(self):
         if self.__stopped.done():
@@ -563,77 +554,3 @@ def message(self):
     def message(self, value):
         self._message = value
 
-
-class ViewStore:
-    def __init__(self, state: ConnectionState):
-        # (component_type, message_id, custom_id): (View, Item)
-        self._views: dict[tuple[int, int | None, str], tuple[View, Item]] = {}
-        # message_id: View
-        self._synced_message_views: dict[int, View] = {}
-        self._state: ConnectionState = state
-
-    @property
-    def persistent_views(self) -> Sequence[View]:
-        views = {
-            view.id: view
-            for (_, (view, _)) in self._views.items()
-            if view.is_persistent()
-        }
-        return list(views.values())
-
-    def __verify_integrity(self):
-        to_remove: list[tuple[int, int | None, str]] = []
-        for k, (view, _) in self._views.items():
-            if view.is_finished():
-                to_remove.append(k)
-
-        for k in to_remove:
-            del self._views[k]
-
-    def add_view(self, view: View, message_id: int | None = None):
-        self.__verify_integrity()
-
-        view._start_listening_from_store(self)
-        for item in view.children:
-            if item.is_dispatchable():
-                self._views[(item.type.value, message_id, item.custom_id)] = (view, item)  # type: ignore
-
-        if message_id is not None:
-            self._synced_message_views[message_id] = view
-
-    def remove_view(self, view: View):
-        for item in view.children:
-            if item.is_dispatchable():
-                self._views.pop((item.type.value, item.custom_id), None)  # type: ignore
-
-        for key, value in self._synced_message_views.items():
-            if value.id == view.id:
-                del self._synced_message_views[key]
-                break
-
-    def dispatch(self, component_type: int, custom_id: str, interaction: Interaction):
-        self.__verify_integrity()
-        message_id: int | None = interaction.message and interaction.message.id
-        key = (component_type, message_id, custom_id)
-        # Fallback to None message_id searches in case a persistent view
-        # was added without an associated message_id
-        value = self._views.get(key) or self._views.get(
-            (component_type, None, custom_id)
-        )
-        if value is None:
-            return
-
-        view, item = value
-        item.refresh_state(interaction)
-        view._dispatch_item(item, interaction)
-
-    def is_message_tracked(self, message_id: int):
-        return message_id in self._synced_message_views
-
-    def remove_message_tracking(self, message_id: int) -> View | None:
-        return self._synced_message_views.pop(message_id, None)
-
-    def update_from_message(self, message_id: int, components: list[ComponentPayload]):
-        # pre-req: is_message_tracked == true
-        view = self._synced_message_views[message_id]
-        view.refresh([_component_factory(d) for d in components])