scurrypy 0.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

{discord → scurrypy}/resources/interaction.py

@@ -4,12 +4,10 @@ from typing import Optional, Unpack
 from ..http import HTTPClient
 from ..model import DataModel
 
-from ..parts.modal import ModalBuilder
-from ..parts.message import *
+from ..parts.modal import ModalPart
+from ..parts.message import MessagePart, MessageFlagParams
 
-from ..models.guild import GuildModel
-from ..models.member import MemberModel
-from ..models.interaction import InteractionCallbackModel
+from ..models import GuildModel, MemberModel, InteractionCallbackModel
 
 from .channel import Channel
 
@@ -38,8 +36,9 @@ class InteractionCallbackTypes:
     """Acknowledge an interaction and edit a response later. User sees a loading state."""
 
     DEFERRED_UPDATE_MESSAGE = 6
-    """Acknowledge an interaction and edit the original message later. 
-    The user does NOT see a loading state. (Components only)
+    """
+        Acknowledge an interaction and edit the original message later. 
+        The user does NOT see a loading state. (Components only)
     """
 
     UPDATE_MESSAGE = 7
@@ -68,7 +67,7 @@ class Interaction(DataModel):
     """HTTP session for requests."""
 
     type: int
-    """Type of interaction."""
+    """Type of interaction. See [`InteractionTypes`][scurrypy.dispatch.command_dispatcher.InteractionTypes]."""
 
     channel_id: int
     """ID of the channel where the interaction was sent."""
@@ -97,81 +96,89 @@ class Interaction(DataModel):
     channel: Optional[Channel] = None
     """Partial channel object the interaction was invoked."""
 
-    async def respond(self, message: str | MessageBuilder, with_response: bool = False, **flags: Unpack[MessageFlagParams]):
+    def _prepare_message(self, message: MessagePart, t: int):
+        """Prepares a message to be sent to HTTPClient.
+
+        Args:
+            message (MessagePart): the message content
+            t (int): the interaction type. See [`InteractionTypes`][scurrypy.dispatch.command_dispatcher.InteractionTypes].
+
+        Returns:
+            (dict): the complete interaction content payload
+        """
+        # set attachment IDs (if any)
+        if message.attachments:
+            for idx, file in enumerate(message.attachments):
+                file.id = idx
+
+        return {'type': t, 'data': message.to_dict()}
+
+    async def respond(self, message: str | MessagePart, with_response: bool = False, **flags: Unpack[MessageFlagParams]):
         """Create a message in response to an interaction.
 
         Args:
-            message (str | MessageBuilder): content as a string or from MessageBuilder
+            message (str | MessagePart): content as a string or from MessagePart
             with_response (bool, optional): if the interaction data should be returned. Defaults to False.
+            **flags: message flags to set. (set respective flag to True to toggle.)
 
         Raises:
-            TypeError: invalid type
+            TypeError: invalid `message` type
         """
         if isinstance(message, str):
-            message = MessageBuilder(content=message).set_flags(**flags)
-        elif not isinstance(message, MessageBuilder):
-            raise TypeError(f"Interaction.respond expects type str or MessageBuilder, got {type(message).__name__}")
-
-        content = {
-            'type': InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE,
-            'data': message._to_dict()
-        }
-
-        params = {'with_response': with_response}
-
+            message = MessagePart(content=message).set_flags(**flags)
+        elif not isinstance(message, MessagePart):
+            raise TypeError(f"Interaction.respond expects type str or MessagePart, got {type(message).__name__}")
+        
         data = await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content, 
+            data=self._prepare_message(message, InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE), 
             files=[fp.path for fp in message.attachments],
-            params=params)
+            params={'with_response': with_response}
+        )
 
         if with_response:
             return InteractionCallbackModel.from_dict(data, self._http)
         
-    async def update(self, message: str | MessageBuilder, **flags: Unpack[MessageFlagParams]):
+    async def update(self, message: str | MessagePart, **flags: Unpack[MessageFlagParams]):
         """Update a message in response to an interaction.
 
         Args:
-            message (str | MessageBuilder): content as a string or from MessageBuilder
+            message (str | MessagePart): content as a string or from MessagePart
+            **flags: message flags to set
 
         Raises:
-            TypeError: invalid type
+            TypeError: invalid `message` type
         """
         if isinstance(message, str):
-            message = MessageBuilder(content=message).set_flags(**flags)
-        elif not isinstance(message, MessageBuilder):
-            raise TypeError(f"Interaction.update expects type str or MessageBuilder, got {type(message).__name__}")
-
-        content = {
-            'type': InteractionCallbackTypes.UPDATE_MESSAGE,
-            'data': message._to_dict()
-        }
+            message = MessagePart(content=message).set_flags(**flags)
+        elif not isinstance(message, MessagePart):
+            raise TypeError(f"Interaction.update expects type str or MessagePart, got {type(message).__name__}")
 
         await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content, 
+            data=self._prepare_message(message, InteractionCallbackTypes.UPDATE_MESSAGE), 
             files=[fp.path for fp in message.attachments])
 
-    async def respond_modal(self, modal: ModalBuilder):
+    async def respond_modal(self, modal: ModalPart):
         """Create a modal in response to an interaction.
 
         Args:
-            modal (ModalBuilder): modal data
+            modal (ModalPart): modal data
 
         Raises:
-            TypeError: invalid type
+            TypeError: invalid `modal` type
         """
-        if not isinstance(modal, ModalBuilder):
-            raise TypeError(f"Interaction.respond_modal expects type ModalBuilder, got {type(modal).__name__}")
+        if not isinstance(modal, ModalPart):
+            raise TypeError(f"Interaction.respond_modal expects type ModalPart, got {type(modal).__name__}")
         
         content = {
             'type': InteractionCallbackTypes.MODAL,
-            'data': modal._to_dict()
+            'data': modal.to_dict()
         }
 
         await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content)
+            data=content)

{discord → scurrypy}/resources/message.py

@@ -4,9 +4,8 @@ from typing import Optional
 from ..http import HTTPClient
 from ..model import DataModel
 
-from ..models.user import UserModel
-from ..models.emoji import EmojiModel
-from ..parts.message import MessageBuilder
+from ..models import UserModel, EmojiModel
+from ..parts.message import MessagePart
 
 @dataclass
 class Message(DataModel):
@@ -41,7 +40,7 @@ class Message(DataModel):
         self.__dict__.update(Message.from_dict(data, self._http).__dict__)
 
     async def fetch(self):
-        """Fetches the message data based on the given channel id and message id.
+        """Fetches the message data based on the given channel ID and message id.
 
         Returns:
             (Message): the message object
@@ -50,67 +49,67 @@ class Message(DataModel):
 
         return Message.from_dict(data, self._http)
 
-    async def send(self, message: str | MessageBuilder):
+    async def send(self, message: str | MessagePart):
         """Sends a new message to the current channel.
 
         Permissions:
             * SEND_MESSAGES → required to senf your own messages
 
         Args:
-            message (str | MessageBuilder): can be just text or the MessageBuilder for dynamic messages
+            message (str | MessagePart): can be just text or the MessagePart for dynamic messages
 
         Returns:
             (Message): the new Message object with all fields populated
         """
         if isinstance(message, str):
-            message = MessageBuilder(content=message)
+            message = MessagePart(content=message)
 
         data = await self._http.request(
             "POST",
             f"/channels/{self.channel_id}/messages",
-            message._to_dict(),
+            data=message.to_dict(),
             files=[fp.path for fp in message.attachments] if message.attachments else None
         )
         return Message.from_dict(data, self._http)
 
-    async def edit(self, message: str | MessageBuilder):
+    async def edit(self, message: str | MessagePart):
         """Edits this message.
 
         Permissions:
             * MANAGE_MESSAGES → ONLY if editing another user's message
 
         Args:
-            message (str | MessageBuilder): can be just text or the MessageBuilder for dynamic messages
+            message (str | MessagePart): can be just text or the MessagePart for dynamic messages
         """
         if isinstance(message, str):
-            message = MessageBuilder(content=message)
+            message = MessagePart(content=message)
 
         data = await self._http.request(
             "PATCH", 
             f"/channels/{self.channel_id}/messages/{self.id}", 
-            message._to_dict(),
+            data=message.to_dict(),
             files=[fp.path for fp in message.attachments] if message.attachments else None)
 
         self._update(data)
 
-    async def reply(self, message: str | MessageBuilder):
+    async def reply(self, message: str | MessagePart):
         """Reply to this message with a new message.
 
         Permissions:
             * SEND_MESSAGES → required to send the message
 
         Args:
-            message (str | MessageBuilder): the new message
+            message (str | MessagePart): the new message
         """
         if isinstance(message, str):
-            message = MessageBuilder(content=message)
+            message = MessagePart(content=message)
 
         message = message._set_reference(self.id, self.channel_id)
 
         await self._http.request(
             'POST', 
             f"/channels/{self.channel_id}/messages",
-            message._to_dict(),
+            data=message.to_dict(),
             files=[fp.path for fp in message.attachments] if message.attachments else None)
 
     async def crosspost(self):

{discord → scurrypy}/resources/user.py

@@ -4,8 +4,7 @@ from typing import Optional, TypedDict, Unpack
 from ..http import HTTPClient
 from ..model import DataModel
 
-from ..models.guild import GuildModel
-from ..models.member import MemberModel
+from ..models import GuildModel, MemberModel
 
 class FetchUserGuildsParams(TypedDict, total=False):
     before: int
@@ -78,7 +77,7 @@ class User(DataModel):
             Requires the OAuth2 guilds scope!
 
         Args:
-            kwargs: Field-specific data
+            **kwargs: user guilds fetch params
                 !!! note
                     If no kwargs are provided, default to 200 guilds limit.
 
@@ -101,7 +100,7 @@ class User(DataModel):
             Requires the OAuth2 guilds.members.read scope!
 
         Args:
-            guild_id (int): id of guild to fetch data from
+            guild_id (int): ID of guild to fetch data from
 
         Returns:
             (MemberModel): member data from guild

scurrypy-0.6.6.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: scurrypy
+Version: 0.6.6
+Summary: Dataclass-driven Discord API Wrapper in Python
+Author: Furmissile
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: websockets>=11.0.0
+Dynamic: license-file
+
+# __ScurryPy__
+
+[![PyPI version](https://badge.fury.io/py/scurrypy.svg)](https://badge.fury.io/py/scurrypy)
+
+A dataclass-driven Discord API wrapper in Python!
+
+While this wrapper is mainly used for various squirrel-related shenanigans, it can also be used for more generic bot purposes.
+
+## Features
+* Easy to extend
+* Command, and event handling
+* Unix shell-style wildcards for component routing
+* Declarative style using decorators
+* Supports both legacy and new features
+* Respects Discord's rate limits
+* No `__future__` hacks to avoid circular import
+* Capable of sharding
+
+## Benchmarks
+Not convinced ScurryPy has a place among top libraries? See the benchmarks below!
+
+### Test Environment
+
+- **Python**: 3.11.6
+- **OS**: Windows 11
+
+### Results Summary
+
+```
+Library         Time (ms)    Memory Δ (MB)      Objects
+--------------------------------------------------------
+scurrypy              8.9             0.44         1417
+hikari             1710.3            27.67        53658
+discord             252.5             7.64        14099
+disnake             185.9             6.31        12111
+```
+
+*(See `tests/benchmark.py` for how this test was done.)*
+
+## Getting Started
+
+*Note: This section also appears in the documentation, but here are complete examples ready to use with your bot credentials.*
+
+### Installation
+
+To install the ScurryPy package, run:
+
+```bash
+pip install scurrypy
+```
+
+## Minimal Slash Command
+
+The following demonstrates building and responding to a slash command.
+
+```py
+import scurrypy
+
+client = scurrypy.Client(
+    token='your-token',
+    application_id=APPLICATION_ID  # your bot's application ID
+)
+
+@client.command(
+    scurrypy.SlashCommand('example', 'Demonstrate the minimal slash command!'), 
+    GUILD_ID  # must be a guild ID your bot is in
+)
+async def example(bot: scurrypy.Client, event: scurrypy.InteractionEvent):
+    await event.interaction.respond(f'Hello, {event.interaction.member.user.username}!')
+
+client.run()
+```
+
+## Minimal Prefix Command (Legacy)
+
+The following demonstrates building and responding to a message prefix command.
+
+```py
+import scurrypy
+
+client = scurrypy.Client(
+    token='your-token',
+    application_id=APPLICATION_ID,  # your bot's application ID
+    intents=scurrypy.set_intents(message_content=True),
+    prefix='!'  # your custom prefix
+)
+
+@client.prefix_command("ping")
+async def on_ping(bot: scurrypy.Client, event: scurrypy.MessageCreateEvent):
+    await event.message.send("Pong!")
+
+client.run()
+```
+
+## Like What You See?
+Explore the full [documentation](https://furmissile.github.io/scurrypy) for more examples, guides, and API reference.

scurrypy-0.6.6.dist-info/RECORD

@@ -0,0 +1,47 @@
+scurrypy/__init__.py,sha256=K5ErF9oKh8onuCb5hgurv1RUJ3X7V2dkm1RumNyc7mc,10258
+scurrypy/client.py,sha256=1_JP2N_rkywx3OS_Hkk9Mh_7W9gsPyeMUo4PrMR0eA0,12131
+scurrypy/client_like.py,sha256=aeHt2g5R0x86RjW1ExckjmkBSo4W4_FvZfLjcRsUoC8,586
+scurrypy/config.py,sha256=OH1A2mNKhDlGvQYASEsVUx2pNxP1YQ2a7a7z-IM5xFg,200
+scurrypy/error.py,sha256=8-YaSVf-fZ8FDAzP-_JWGo86HI3MEcU6C4RAXgnSGiw,1801
+scurrypy/gateway.py,sha256=5qyRRVpG4rQ2o75olPWMEvo_1sO2Pk4sNV1WFvn20S4,6673
+scurrypy/http.py,sha256=KxEXPPraxEayaIZDPFxsQ9o_zsxbZkt5Bjs3zqXrwU4,10785
+scurrypy/intents.py,sha256=PiTC48ommAdDnZHiJWBHKVx5n2ESO1KXWR7jCUv_lPs,2707
+scurrypy/logger.py,sha256=_P12YGaaD6X79-q9_KT1727gcKn2n3CFDpnTOtNZfxQ,3235
+scurrypy/model.py,sha256=vJS2pxJ9yS1zxypWNUnbkqzNqBDaytTUDiXfLM0k364,2372
+scurrypy/models.py,sha256=MnBguAdtGTbbiAUZp8Y6Z45FBPq9vCKtWGqWnGHdjwk,6222
+scurrypy/dispatch/__init__.py,sha256=m7ixrbNhOV9QRORXPw6LSwxofQMAvLmPFBweBZu9ACc,20
+scurrypy/dispatch/command_dispatcher.py,sha256=1vC4cRO2CZdDN02lMUWBk5wpI5x-89cLMi1eQ7YYdoo,7953
+scurrypy/dispatch/event_dispatcher.py,sha256=ij77mHNfleVlKMJk5WfXQSSe3eRWtPfCY1amPiejpEM,3770
+scurrypy/dispatch/prefix_dispatcher.py,sha256=Qrd5luIi-1Y0ZtpQ6xcHRp9Up5wZnNMBm3p8-kwnWNk,2592
+scurrypy/events/__init__.py,sha256=xE8YtJ7NKZkm7MLnohDQIbezh3ColmLR-3BMiZabt3k,18
+scurrypy/events/channel_events.py,sha256=ZTby2wSTNyd_rqt4PzEt4r-WlfcNPGCxJusoizL-ScA,1573
+scurrypy/events/gateway_events.py,sha256=jvTECmiQjabAHIDvKMzLDVx4BNU4gLaRKR-jFAewoV0,735
+scurrypy/events/guild_events.py,sha256=qzQjVeHugC2yzPxARtnTEV7t50S8UZJJHTnPueI4IJY,895
+scurrypy/events/hello_event.py,sha256=O8Ketu_N943cnGaFkGsAHfWhgKXFQCYCqSD3EqdsXjA,225
+scurrypy/events/interaction_events.py,sha256=ZQXwdpN9b5RvITPbLm9yxatvSo2AgP_MxnimIsbm8Tc,4769
+scurrypy/events/message_events.py,sha256=ht5TApYq0vS_-1w8bizJUkO9E00YcSA6-auWFXX7vTE,1578
+scurrypy/events/reaction_events.py,sha256=j6twbQca3whp-vW0xDhA8fX0vsWL0aqenDms6tzZVNU,2609
+scurrypy/events/ready_event.py,sha256=FpT6zwy14ftOwncbKhUcadYeH1zo5J2icNreGasNwpY,729
+scurrypy/parts/__init__.py,sha256=yROb-BqEw-FKXqq_-0WbP33U-Arm_9NpJuEamXpvjeA,19
+scurrypy/parts/channel.py,sha256=iyYUq3swQkGeOkR4aM7tpvaiP2xtOJ69Asuf4G3nuIg,1194
+scurrypy/parts/command.py,sha256=PtgGqh-5qjvKuDkVgLJh5Cw0GP1T55g4DgzMvFivnJw,2321
+scurrypy/parts/component_types.py,sha256=qr1R0jzXpE_h9Xv4P5DyYRSuhxS0Qnm9aag-JKrJvBA,131
+scurrypy/parts/components.py,sha256=RTg456-zothOtYkMv0vbCxQ-e_b14xObxMnMunHDWV8,7760
+scurrypy/parts/components_v2.py,sha256=lHcq_F25uHoS-ZkhtetFsrRD0ser6sROHu0F8X-68h4,5481
+scurrypy/parts/embed.py,sha256=-K6MqBB0r1GlGHJQtAVIQ6FcTnncYccIGY6sRPHuVsc,2056
+scurrypy/parts/message.py,sha256=GHI2mZ4DCiwB2eGAoNw8c09Kw6YTkJe7QQF9IxXwLlQ,4130
+scurrypy/parts/modal.py,sha256=u7M01oLMkBJP1P6QUvciYWVMEXHvmLw1AnG_jHxbg-w,417
+scurrypy/parts/role.py,sha256=fnEIlbZih-X-vDkr1zXtN9xYcpQtcsgTLZZVY_SAQh4,622
+scurrypy/resources/__init__.py,sha256=EdzYKftSLqqr3Bpzc0_90kfozJXOtp9jNTIHhCTt_-0,21
+scurrypy/resources/application.py,sha256=DIjv64Jboj7ub1j_PKp9aVzVOGRxvcC3axm3Hx5plqY,2733
+scurrypy/resources/bot_emojis.py,sha256=gNbe6xbiEf9X3Tl1lgGulrv9zUSj9qzi8_JPzLVwink,1695
+scurrypy/resources/channel.py,sha256=QGS5IWw_zvquyC4pWhBf4nvhzRaZUBtM1D562dQvEzU,6992
+scurrypy/resources/guild.py,sha256=H5rsv6xSUxQ9y66JAb1U2gGpGLujGxpMVIZuJYp52_I,8143
+scurrypy/resources/interaction.py,sha256=LPNR3cqbBHg5BV1bgyy8EGqelKT-zNMLZBGlFAh4PVM,6582
+scurrypy/resources/message.py,sha256=PudYpCQdEUf8R7jpKtV2ZVwWZ0s7vVranCZYlkMQvkw,7471
+scurrypy/resources/user.py,sha256=8pXP6gN2oHV7aFoD9ayNCVk5-UPDPzkflATSiD_PvgY,3058
+scurrypy-0.6.6.dist-info/licenses/LICENSE,sha256=lFWI-P5B2ASgxejVH-WesuAFVXwbfr9moST2RrdlIMQ,791
+scurrypy-0.6.6.dist-info/METADATA,sha256=o33AWKvEcwnFQD8ndujDoCUprgXftORWdYK7Bl3YV-8,3040
+scurrypy-0.6.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scurrypy-0.6.6.dist-info/top_level.txt,sha256=cP1rrlCOPlavqRZ3JbawO-xKi4QcIWa2VHz2DBf3po4,9
+scurrypy-0.6.6.dist-info/RECORD,,

{scurrypy-0.4.dist-info → scurrypy-0.6.6.dist-info}/licenses/LICENSE

@@ -13,4 +13,4 @@ and its source code, provided that:
    implied. The author assumes no liability for any damages arising from its use.
 
 5. This software may not be used for commercial purposes without written consent 
-    from the author.
+   from the author.

scurrypy-0.6.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+scurrypy

discord/__init__.py

@@ -1,223 +0,0 @@
-# discord
-
-import importlib
-from typing import TYPE_CHECKING
-
-__all__ = [
-    # top-level
-    "Logger",
-    "Client",
-    "Intents",
-    "set_intents",
-    "BaseConfig",
-
-    # events
-    "ReadyEvent",
-    "ReactionAddEvent",
-    "ReactionRemoveEvent",
-    "ReactionRemoveEmojiEvent",
-    "ReactionRemoveAllEvent",
-    "GuildCreateEvent",
-    "GuildUpdateEvent",
-    "GuildDeleteEvent",
-    "MessageCreateEvent",
-    "MessageUpdateEvent",
-    "MessageDeleteEvent",
-    "GuildChannelCreateEvent",
-    "GuildChannelUpdateEvent",
-    "GuildChannelDeleteEvent",
-    "ChannelPinsUpdateEvent",
-    "InteractionEvent",
-
-    # models
-    "ApplicationModel",
-    "EmojiModel",
-    "GuildModel",
-    "MemberModel",
-    "UserModel",
-    "RoleModel",
-
-    # parts
-    "GuildChannel",
-    "Role",
-    "MessageBuilder",
-    "ModalBuilder",
-    "EmbedBuilder",
-    "ActionRow",
-    "StringSelect",
-    "UserSelect",
-    "RoleSelect",
-    "ChannelSelect",
-    "MentionableSelect",
-    "SlashCommand",
-    "MessageCommand",
-    "UserCommand",
-    "Container",
-    "Section",
-    "MediaGalleryItem",
-    "Label",
-
-    # resources
-    "Guild",
-    "Channel",
-    "Message",
-    "BotEmojis",
-    "User",
-    "Interaction",
-    "Application",
-]
-
-# For editor support / autocomplete
-if TYPE_CHECKING:
-    from .logger import Logger
-    from .client import Client
-    from .intents import Intents, set_intents
-    from .config import BaseConfig
-
-    # events
-    from .events.ready_event import ReadyEvent
-    from .events.reaction_events import (
-        ReactionAddEvent,
-        ReactionRemoveEvent,
-        ReactionRemoveEmojiEvent,
-        ReactionRemoveAllEvent,
-    )
-    from .events.guild_events import (
-        GuildCreateEvent,
-        GuildUpdateEvent,
-        GuildDeleteEvent,
-    )
-    from .events.message_events import (
-        MessageCreateEvent,
-        MessageUpdateEvent,
-        MessageDeleteEvent,
-    )
-    from .events.channel_events import (
-        GuildChannelCreateEvent,
-        GuildChannelUpdateEvent,
-        GuildChannelDeleteEvent,
-        ChannelPinsUpdateEvent,
-    )
-    from .events.interaction_events import InteractionEvent
-
-    # models
-    from .models.application import ApplicationModel
-    from .models.emoji import EmojiModel
-    from .models.guild import GuildModel
-    from .models.member import MemberModel
-    from .models.user import UserModel
-    from .models.role import RoleModel
-
-    # parts
-    from .parts.channel import GuildChannel
-    from .parts.role import Role
-    from .parts.message import MessageBuilder
-    from .parts.modal import ModalBuilder
-    from .parts.embed import EmbedBuilder
-    from .parts.action_row import (
-        ActionRow, 
-        StringSelect,
-        UserSelect,
-        RoleSelect,
-        ChannelSelect,
-        MentionableSelect
-    )
-
-    from .parts.command import (
-        SlashCommand, 
-        MessageCommand, 
-        UserCommand
-    )
-
-    from .parts.components_v2 import (
-        Container,
-        Section,
-        MediaGalleryItem,
-        Label
-    )
-
-    # resources
-    from .resources.guild import Guild
-    from .resources.channel import Channel
-    from .resources.message import Message
-    from .resources.bot_emojis import BotEmojis
-    from .resources.user import User
-    from .resources.interaction import Interaction
-    from .resources.application import Application
-
-# Lazy loader
-def __getattr__(name: str):
-    if name not in __all__:
-        raise AttributeError(f"module {__name__} has no attribute {name}")
-
-    mapping = {
-        # top-level
-        "Logger": "discord.logger",
-        "Client": "discord.client",
-        "Intents": "discord.intents",
-        "set_intents": "discord.intents",
-        "BaseConfig": "discord.config",
-
-        # events
-        "ReadyEvent": "discord.events.ready_event",
-        "ReactionAddEvent": "discord.events.reaction_events",
-        "ReactionRemoveEvent": "discord.events.reaction_events",
-        "ReactionRemoveEmojiEvent": "discord.events.reaction_events",
-        "ReactionRemoveAllEvent": "discord.events.reaction_events",
-        "GuildCreateEvent": "discord.events.guild_events",
-        "GuildUpdateEvent": "discord.events.guild_events",
-        "GuildDeleteEvent": "discord.events.guild_events",
-        "MessageCreateEvent": "discord.events.message_events",
-        "MessageUpdateEvent": "discord.events.message_events",
-        "MessageDeleteEvent": "discord.events.message_events",
-        "GuildChannelCreateEvent": "discord.events.channel_events",
-        "GuildChannelUpdateEvent": "discord.events.channel_events",
-        "GuildChannelDeleteEvent": "discord.events.channel_events",
-        "ChannelPinsUpdateEvent": "discord.events.channel_events",
-        "InteractionEvent": "discord.events.interaction_events",
-
-        # models
-        'ApplicationModel': "discord.models.application",
-        'EmojiModel': "discord.models.emoji",
-        'GuildModel': "discord.models.guild",
-        'MemberModel': "discord.models.member",
-        'UserModel': "discord.models.user",
-        'RoleModel': "discord.models.role",
-
-        # parts
-        'GuildChannel': "discord.parts.channel",
-        'Role': "discord.parts.role",
-        'MessageBuilder': "discord.parts.message",
-        'ModalBuilder': "discord.parts.modal",
-        'EmbedBuilder': "discord.parts.embed",
-        'ActionRow': "discord.parts.action_row",
-        'StringSelect': "discord.parts.action_row",
-        'UserSelect': "discord.parts.action_row",
-        'RoleSelect': "discord.parts.action_row",
-        'ChannelSelect': "discord.parts.action_row",
-        'MentionableSelect': "discord.parts.action_row",
-        'SlashCommand': "discord.parts.command",
-        'MessageCommand': "discord.parts.command",
-        'UserCommand': "discord.parts.command",
-        'Container': "discord.parts.components_v2",
-        'Section': "discord.parts.components_v2",
-        'MediaGalleryItem': "discord.parts.components_v2",
-        'Label': "discord.parts.components_v2",
-
-        # resources
-        'Guild': "discord.resources.guild",
-        'Channel': "discord.resources.channel",
-        'Message': "discord.resources.message",
-        'BotEmojis': "discord.resources.bot_emojis",
-        'User': "discord.resources.user",
-        'Interaction': "discord.resources.interaction",
-        'Application': "discord.resources.application"
-    }
-
-    module = importlib.import_module(mapping[name])
-    attr = getattr(module, name)
-    globals()[name] = attr  # cache it for future lookups
-    return attr
-
-def __dir__():
-    return sorted(list(globals().keys()) + __all__)