scurrypy 0.3.2__py3-none-any.whl → 0.3.4.1__py3-none-any.whl

discord/__init__.py

@@ -1,10 +1,223 @@
 # discord
 
-from .logger import Logger
-from .client import Client
-from .intents import Intents, set_intents
-from .config import BaseConfig
-
-from .events import *
-from .resources import *
-from .parts import *
+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__)

discord/client.py

@@ -1,26 +1,12 @@
 import asyncio
 
-from .logger import Logger
-from .gateway import GatewayClient
-from .http import HTTPClient
+from .config import BaseConfig
 from .intents import Intents
 from .error import DiscordError
-from .config import BaseConfig
 from .client_like import ClientLike
 
-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.application import Application
-
 from .parts.command import SlashCommand, MessageCommand, UserCommand
 
-from .dispatch.event_dispatcher import EventDispatcher
-from .dispatch.prefix_dispatcher import PrefixDispatcher
-from .dispatch.command_dispatcher import CommandDispatcher
-
 class Client(ClientLike):
     """Main entry point for Discord bots.
         Ties together the moving parts: gateway, HTTP, event dispatching, command handling, and resource managers.
@@ -45,6 +31,19 @@ class Client(ClientLike):
             prefix (str, optional): set message prefix if using command prefixes
             quiet (bool, optional): if INFO, DEBUG, and WARN should be logged
         """
+        if not token:
+            raise ValueError("Token is required")
+        if not application_id:
+            raise ValueError("Application ID is required")
+        
+        from .logger import Logger
+        from .gateway import GatewayClient
+        from .http import HTTPClient
+        from .resources.bot_emojis import BotEmojis
+        from .dispatch.event_dispatcher import EventDispatcher
+        from .dispatch.prefix_dispatcher import PrefixDispatcher
+        from .dispatch.command_dispatcher import CommandDispatcher
+
         self.token = token
         self.application_id = application_id
         self.config = config
@@ -90,30 +89,41 @@ class Client(ClientLike):
             return func
         return decorator
 
-    def command(self, command: SlashCommand | MessageCommand | UserCommand, guild_id: int = 0):
-        """Decorator registers a function for a command handler.
+    def command(self, command: SlashCommand | MessageCommand | UserCommand, guild_ids: list[int] | None = None):
+        """Decorator to register a function as a command handler.
 
         Args:
-            command (SlashCommand | MessageCommand | UserCommand): command to register
-            guild_id (int): ID of guild in which to register command (if a guild command)
+            command (SlashCommand | MessageCommand | UserCommand): The command to register.
+            guild_ids (list[int] | None): Guild IDs for guild-specific commands. None for global commands.
         """
         def decorator(func):
-            # hash out command type
-            if isinstance(command, MessageCommand):
-                self.command_dispatcher.message_command(command.name, func)
-            elif isinstance(command, UserCommand):
-                self.command_dispatcher.user_command(command.name, func)
-            elif isinstance(command, SlashCommand):
-                self.command_dispatcher.command(command.name, func)
+            # Map command types to dispatcher registration functions
+            handler_map = {
+                MessageCommand: self.command_dispatcher.message_command,
+                UserCommand: self.command_dispatcher.user_command,
+                SlashCommand: self.command_dispatcher.command,
+            }
+
+            # Resolve dispatcher method based on command type
+            for cls, handler in handler_map.items():
+                if isinstance(command, cls):
+                    handler(command.name, func)
+                    break
             else:
-                raise ValueError(f'Command {command.name} expected to be of type SlashCommand, UserCommand, MessageCommand; \
-                    got {type(command).__name__}.')
-            
-            # then hash out if this command should be guild or global level
-            if guild_id != 0:
-                self._guild_commands.setdefault(guild_id, []).append(command)
+                raise ValueError(
+                    f"Command {getattr(command, 'name', '<unnamed>')} must be one of "
+                    f"SlashCommand, UserCommand, MessageCommand; got {type(command).__name__}."
+                )
+
+            # Queue command for later registration
+            if guild_ids:
+                gids = [guild_ids] if isinstance(guild_ids, int) else guild_ids
+                for gid in gids:
+                    self._guild_commands.setdefault(gid, []).append(command)
             else:
                 self._global_commands.append(command)
+
+            return func  # ensure original function is preserved
         return decorator
     
     def event(self, event_name: str):
@@ -145,7 +155,7 @@ class Client(ClientLike):
         """
         self._shutdown_hooks.append(func)
 
-    def application_from_id(self, application_id: int):
+    def fetch_application(self, application_id: int):
         """Creates an interactable application resource.
 
         Args:
@@ -154,9 +164,11 @@ class Client(ClientLike):
         Returns:
             (Application): the Application resource
         """
+        from .resources.application import Application
+
         return Application(application_id, self._http)
 
-    def guild_from_id(self, guild_id: int):
+    def fetch_guild(self, guild_id: int):
         """Creates an interactable guild resource.
 
         Args:
@@ -165,9 +177,11 @@ class Client(ClientLike):
         Returns:
             (Guild): the Guild resource
         """
+        from .resources.guild import Guild
+
         return Guild(guild_id, self._http)
 
-    def channel_from_id(self, channel_id: int):
+    def fetch_channel(self, channel_id: int):
         """Creates an interactable channel resource.
 
         Args:
@@ -176,9 +190,11 @@ class Client(ClientLike):
         Returns:
             (Channel): the Channel resource
         """
+        from .resources.channel import Channel
+
         return Channel(channel_id, self._http)
 
-    def message_from_id(self, channel_id: int, message_id: int):
+    def fetch_message(self, channel_id: int, message_id: int):
         """Creates an interactable message resource.
 
         Args:
@@ -188,9 +204,11 @@ class Client(ClientLike):
         Returns:
             (Message): the Message resource
         """
+        from .resources.message import Message
+
         return Message(message_id, channel_id, self._http)
     
-    def user_from_id(self, user_id: int):
+    def fetch_user(self, user_id: int):
         """Creates an interactable user resource.
 
         Args:
@@ -199,6 +217,8 @@ class Client(ClientLike):
         Returns:
             (User): the User resource
         """
+        from .resources.user import User
+
         return User(user_id, self._http)
     
     async def clear_guild_commands(self, guild_id: int):
@@ -211,11 +231,11 @@ class Client(ClientLike):
             self._logger.log_info(f"Guild {guild_id} already queued, skipping clear.")
             return
 
-        await self.command_dispatcher._register_guild_commands({guild_id: []})
+        self._guild_commands[guild_id] = []
 
     async def _listen(self):
         """Main event loop for incoming gateway requests."""
-        while True:
+        while self._ws.is_connected():
             try:
                 message = await self._ws.receive()
                 if not message:
@@ -223,17 +243,17 @@ class Client(ClientLike):
 
                 op_code = message.get('op')
 
-                if op_code == 0:
-                    dispatch_type = message.get('t')
-                    self._logger.log_info(f"DISPATCH -> {dispatch_type}")
-                    event_data = message.get('d')
-                    self._ws.sequence = message.get('s') or self._ws.sequence
+                match op_code:
+                    case 0:
+                        dispatch_type = message.get('t')
+                        self._logger.log_info(f"DISPATCH -> {dispatch_type}")
+                        event_data = message.get('d')
+                        self._ws.sequence = message.get('s') or self._ws.sequence
 
-                    if dispatch_type == "READY":
-                        self._ws.session_id = event_data.get("session_id")
-                        self._ws.connect_url = event_data.get("resume_gateway_url", self._ws.connect_url)
+                        if dispatch_type == "READY":
+                            self._ws.session_id = event_data.get("session_id")
+                            self._ws.connect_url = event_data.get("resume_gateway_url", self._ws.connect_url)
 
-                    try:
                         if self.prefix_dispatcher.prefix and dispatch_type == 'MESSAGE_CREATE':
                             await self.prefix_dispatcher.dispatch(event_data)
                             
@@ -241,103 +261,97 @@ class Client(ClientLike):
                             await self.command_dispatcher.dispatch(event_data)
 
                         await self.dispatcher.dispatch(dispatch_type, event_data)
-                    except DiscordError as e:
-                        if e.fatal:
-                            raise  # let run() handle fatal errors
-                        else:
-                            self._logger.log_warn(f"Recoverable DiscordError: {e}")
-                            continue  # keep listening
-
-                elif op_code == 7:
-                    raise ConnectionError("Reconnect requested by server.")
-                elif op_code == 9:
-                    self._ws.session_id = None
-                    self._ws.sequence = None
-                    raise ConnectionError("Invalid session.")
+                    case 7:
+                        raise ConnectionError("Reconnect requested by server.")
+                    case 9:
+                        self._ws.session_id = None
+                        self._ws.sequence = None
+                        raise ConnectionError("Invalid session.")
+                    case 11:
+                        self._logger.log_debug("Heartbeat ACK received")
+
             except asyncio.CancelledError:
-                raise
+                break
             except DiscordError as e:
                 if e.fatal:
-                    raise  # propagate fatal errors
+                    self._logger.log_error(f"Fatal DiscordError: {e}")
+                    break
                 else:
                     self._logger.log_warn(f"Recoverable DiscordError: {e}")
             except ConnectionError as e:
                 self._logger.log_warn(f"Connection lost: {e}")
-                await self._ws.close()
-                await asyncio.sleep(2)
+                raise
 
     async def start(self):
         """Runs the main lifecycle of the bot.
             Handles connection setup, heartbeat management, event loop, and automatic reconnects.
         """
-        while True:
-            try:
-                await self._http.start_session()
-                await self._ws.connect()
-                await self._ws.start_heartbeat()
+        try:
+            await self._http.start_session()
+            await self._ws.connect()
+            await self._ws.start_heartbeat()
 
+            while self._ws.is_connected():
                 if self._ws.session_id and self._ws.sequence:
                     await self._ws.reconnect()
                 else:
                     await self._ws.identify()
 
                 if not self._is_set_up:
-                    if self._setup_hooks:
-                        for hook in self._setup_hooks:
-                            self._logger.log_info(f"Setting hook {hook.__name__}")
-                            await hook(self)
-                        self._logger.log_high_priority("Hooks set up.")
+                    await self.startup()
+                    self._is_set_up = True
 
-                    # register GUILD commands
-                    await self.command_dispatcher._register_guild_commands(self._guild_commands)
+                await self._listen()
+                
+                # If we get here, connection was lost - reconnect
+                await self._ws.close() 
+                await asyncio.sleep(5)
+                await self._ws.connect()
+                await self._ws.start_heartbeat()
 
-                    # register GLOBAL commands
-                    await self.command_dispatcher._register_global_commands(self._global_commands)
+        except asyncio.CancelledError:
+            self._logger.log_high_priority("Connection cancelled via KeyboardInterrupt.")
+        except Exception as e:
+            self._logger.log_error(f"{type(e).__name__} - {e}")
+        finally:
+            await self.close()
 
-                    self._is_set_up = True
+    async def startup(self):
+        try:
+            if self._setup_hooks:
+                for hook in self._setup_hooks:
+                    self._logger.log_info(f"Setting hook {hook.__name__}")
+                    await hook(self)
+                self._logger.log_high_priority("Hooks set up.")
 
-                await self._listen()
+            # register GUILD commands
+            await self.command_dispatcher._register_guild_commands(self._guild_commands)
 
-            except ConnectionError as e:
-                self._logger.log_warn("Connection lost. Attempting reconnect...")
-                await self._ws.close()
-                await asyncio.sleep(2)
-                continue
-            except asyncio.CancelledError:
-                self._logger.log_info("Cancelling connection...")
-                break
-            except DiscordError as e:
-                self._logger.log_error(f"Fatal DiscordError: {e}")
-                break
-            except Exception as e:
-                self._logger.log_error(f"Unspecified Error Type {type(e).__name__} - {e}")
-                break
-            finally:
-                # Run hooks (with safe catching)
-                for hook in self._shutdown_hooks:
-                    try:
-                        self._logger.log_info(f"Executing shutdown hook {hook.__name__}")
-                        await hook(self)
-                    except Exception as e:
-                        self._logger.log_error(f"{type(e).__name__}: {e}")
-
-                # Always close resources
-                try:
-                    await self._ws.close()
-                except Exception as e:
-                    self._logger.log_warn(f"WebSocket close failed: {e}")
-
-                try:
-                    await self._http.close_session()
-                except Exception as e:
-                    self._logger.log_warn(f"HTTP session close failed: {e}")
+            # register GLOBAL commands
+            await self.command_dispatcher._register_global_commands(self._global_commands)
 
+            self._logger.log_high_priority("Commands set up.")
+        except Exception:
+            raise
 
+    async def close(self):    
+        """Gracefully close HTTP and websocket connections."""    
+        # Close HTTP first since it's more important
+        self._logger.log_debug("Closing HTTP session...")
+        await self._http.close_session()
+
+        # Then try websocket with short timeout
+        try:
+            self._logger.log_debug("Closing websocket connection...")
+            await asyncio.wait_for(self._ws.close(), timeout=1.0)
+        except:
+            pass  # Don't care if websocket won't close
+        
     def run(self):
         """Starts the bot.
             Handles starting the session, WS, and heartbeat, reconnection logic,
             setting up emojis and hooks, and then listens for gateway events.
-        """
+        """        
         try:
             asyncio.run(self.start())
         except KeyboardInterrupt: