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

discord/client.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from .config import BaseConfig
 from .intents import Intents
 from .error import DiscordError
@@ -29,6 +31,11 @@ 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
@@ -82,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):
@@ -137,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:
@@ -150,7 +168,7 @@ class Client(ClientLike):
 
         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:
@@ -163,7 +181,7 @@ class Client(ClientLike):
 
         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,7 +194,7 @@ class Client(ClientLike):
 
         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:
@@ -190,7 +208,7 @@ class Client(ClientLike):
 
         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:
@@ -213,13 +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."""
-        import asyncio
-
-        while True:
+        while self._ws.is_connected():
             try:
                 message = await self._ws.receive()
                 if not message:
@@ -227,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)
                             
@@ -245,107 +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.
         """
-        import asyncio
-
-        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.
-        """
-        import asyncio
-        
+        """        
         try:
             asyncio.run(self.start())
         except KeyboardInterrupt:

discord/dispatch/event_dispatcher.py

@@ -1,4 +1,4 @@
-from importlib import import_module
+import importlib
 from ..client_like import ClientLike
 
 from ..resources.message import Message
@@ -9,8 +9,24 @@ class EventDispatcher:
     RESOURCE_MAP = { # maps discord events to their respective dataclass (lazy loading)
         'READY': ('discord.events.ready_event', 'ReadyEvent'),
 
-        'MESSAGE_CREATE': ('discord.events.message_events', 'MessageCreateEvent')
+        'GUILD_CREATE': ('discord.events.guild_events', 'GuildCreateEvent'),
+        'GUILD_UPDATE': ('discord.events.guild_events', 'GuildUpdateEvent'),
+        'GUILD_DELETE': ('discord.events.guild_events', 'GuildDeleteEvent'),
+
+        'CHANNEL_CREATE': ('discord.events.channel_events', 'GuildChannelCreateEvent'),
+        'CHANNEL_UPDATE': ('discord.events.channel_events', 'GuildChannelUpdateEvent'),
+        'CHANNEL_DELETE': ('discord.events.channel_events', 'GuildChannelDeleteEvent'),
+        'CHANNEL_PINS_UPDATE': ('discord.events.channel_events', 'ChannelPinsUpdateEvent'),
+
+        'MESSAGE_CREATE': ('discord.events.message_events', 'MessageCreateEvent'),
+        'MESSAGE_UPDATE': ('discord.events.message_events', 'MessageUpdateEvent'),
+        'MESSAGE_DELETE': ('discord.events.message_events', 'MessageDeleteEvent'),
         
+        'MESSAGE_REACTION_ADD': ('discord.events.reaction_events', 'ReactionAddEvent'),
+        'MESSAGE_REACTION_REMOVE': ('discord.events.reaction_events', 'ReactionRemoveEvent'),
+        'MESSAGE_REACTION_REMOVE_ALL': ('discord.events.reaction_events', 'ReactionRemoveAllEvent'),
+        'MESSAGE_REACTION_REMOVE_EMOJI': ('discord.events.reaction_events', 'ReactionRemoveEmojiEvent'),
+
         # and other events...
     }
     
@@ -59,7 +75,7 @@ class EventDispatcher:
         
         module_name, class_name = module_info
 
-        module = import_module(module_name)
+        module = importlib.import_module(module_name)
         if not module:
             print(f"Cannot find module '{module_name}'!")
             return

discord/events/channel_events.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
+from ..model import DataModel
 from typing import Optional
 
 @dataclass
-class GuildChannelEvent:
+class GuildChannelEvent(DataModel):
     """Base guild channel event."""
 
     id: int
@@ -48,5 +49,10 @@ class GuildChannelDeleteEvent(GuildChannelEvent):
 class ChannelPinsUpdateEvent:
     """Pin update event."""
     channel_id: int
+    """ID of channel where the pins were updated."""
+
     guild_id: Optional[int]
+    """ID of the guild where the pins were updated."""
+
     last_pin_timestamp: Optional[str]  # ISO8601 timestamp of last pinned message
+    """ISO8601 formatted timestamp of the last pinned message in the channel."""

discord/events/guild_events.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass
+from ..model import DataModel
+
 from ..models.member import MemberModel
 from ..resources.channel import Channel
 
 @dataclass
-class GuildEvent:
+class GuildEvent(DataModel):
     """Base guild event."""
     joined_at: str
     """ISO8601 timestamp of when app joined the guild."""

discord/events/message_events.py

@@ -1,11 +1,12 @@
 from dataclasses import dataclass
 from typing import Optional
+from ..model import DataModel
 
 from ..resources.message import Message
 from ..models.member import MemberModel
 
 @dataclass
-class MessageCreateEvent:
+class MessageCreateEvent(DataModel):
     """Received when a message is created."""
     message: Message
     """Message resource object. See [`Resource.Message`][discord.resources.message.Message]."""
@@ -17,7 +18,7 @@ class MessageCreateEvent:
     """Partial Member object of the author of the message. See [`MemberModel`][discord.models.member.MemberModel]."""
     
 @dataclass
-class MessageUpdateEvent:
+class MessageUpdateEvent(DataModel):
     """Received when a message is updated."""
     message: Message
     """Message resource object. See [`Resource.Message`][discord.resources.message.Message]."""
@@ -29,7 +30,7 @@ class MessageUpdateEvent:
     """Partial Member object of the author of the message. See [`MemberModel`][discord.models.member.MemberModel]."""
 
 @dataclass
-class MessageDeleteEvent:
+class MessageDeleteEvent(DataModel):
     """Received when a message is deleted."""
 
     id: int

discord/events/reaction_events.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Optional
+from ..model import DataModel
 
 from ..models.member import MemberModel
 from ..models.emoji import EmojiModel
@@ -14,7 +15,7 @@ class ReactionType:
     """A super emoji."""
 
 @dataclass
-class ReactionAddEvent:
+class ReactionAddEvent(DataModel):
     """Reaction added event."""
 
     type: int
@@ -45,7 +46,7 @@ class ReactionAddEvent:
     """ID of the user who sent the message where the reaction was added."""
 
 @dataclass
-class ReactionRemoveEvent:
+class ReactionRemoveEvent(DataModel):
     """Reaction removed event."""
 
     type: int
@@ -69,7 +70,7 @@ class ReactionRemoveEvent:
     burst: bool
     """If the emoji of the removed reaction is super."""
 
-class ReactionRemoveAllEvent:
+class ReactionRemoveAllEvent(DataModel):
     """Remove all reactions event."""
 
     channel_id: int
@@ -82,7 +83,7 @@ class ReactionRemoveAllEvent:
     """ID of the guild where all reaction were removed (if in a guild)."""
 
 @dataclass
-class ReactionRemoveEmojiEvent:
+class ReactionRemoveEmojiEvent(DataModel):
     """All reactions of a specific emoji removed."""
 
     emoji: EmojiModel

discord/gateway.py

@@ -53,57 +53,46 @@ class GatewayClient:
 
     async def connect(self):
         """Established websocket connection to Discord."""
-        try:
-            self.ws = await websockets.connect(self.connect_url + self.url_params)
-            self._logger.log_high_priority("Connected to Discord.")
-        except Exception as e:
-            self._logger.log_error(f"Websocket Connection Error {type(e).__name__} - {e}")
-    
+        self.ws = await websockets.connect(self.connect_url + self.url_params)
+        self._logger.log_high_priority("Connected to Discord.")
+
     async def receive(self):
         """Receives and logs messages from the gateway.
 
         Returns:
             (dict): parsed JSON data
         """
-        try:
-            message = await self.ws.recv()
-            if message:
-                data: dict = json.loads(message)
-                self._logger.log_debug(f"Received: {DISCORD_OP_CODES.get(data.get('op'))} - {json.dumps(data, indent=4)}")
-                self._logger.log_info(f"Received: {DISCORD_OP_CODES.get(data.get('op'))}")
-                return data
-            else:
-                return None
-        except Exception as e:
-            self._logger.log_error(f"Error on receive: {type(e).__name__} - {e}")
-    
+
+        message = await asyncio.wait_for(self.ws.recv(), timeout=60)
+
+        if message:
+            data: dict = json.loads(message)
+            self._logger.log_debug(f"Received: {DISCORD_OP_CODES.get(data.get('op'))} - {json.dumps(data, indent=4)}")
+            self._logger.log_info(f"Received: {DISCORD_OP_CODES.get(data.get('op'))}")
+            return data
+
+        return None
+
     async def send(self, message: dict):
         """Sends a JSON-encoded message to the gateway.
 
         Args:
             message (dict): the message to send
         """
-        try:
-            await self.ws.send(json.dumps(message))
-        except Exception as e:
-            self._logger.log_error(f"Error on send: {type(e).__name__} - {e}")
-        
+        self._logger.log_debug(f"Sending payload: {message}")
+        await self.ws.send(json.dumps(message))
+
     async def send_heartbeat_loop(self):
         """Background task that sends heartbeat payloads in regular intervals.
             Retries until cancelled.
         """
-        try:
-            while True:
-                await asyncio.sleep(self.heartbeat_interval / 1000)
-                hb_data = {"op": 1, "d": self.sequence}
-                await self.send(hb_data)
-                self._logger.log_debug(f"Sending: {hb_data}")
-                self._logger.log_info("Heartbeat sent.")
-        except asyncio.CancelledError:
-            self._logger.log_debug("Heartbeat task cancelled")
-        except Exception as e:
-            self._logger.log_error(f"Error on heartbeat send: {type(e).__name__} - {e}")
-        
+        while self.ws:
+            await asyncio.sleep(self.heartbeat_interval / 1000)
+            hb_data = {"op": 1, "d": self.sequence}
+            await self.send(hb_data)
+            self._logger.log_debug(f"Sending: {hb_data}")
+            self._logger.log_info("Heartbeat sent.")
+
     async def identify(self):
         """Sends the IDENIFY payload (token, intents, connection properties).
             Must be sent after connecting to the WS.
@@ -127,15 +116,12 @@ class GatewayClient:
     
     async def start_heartbeat(self):
         """Waits for initial HELLO event, hydrates the HelloEvent class, and begins the heartbeat."""
-        try:
-            data = await self.receive()
-            hello = HelloEvent.from_dict(data.get('d'))
-            self.heartbeat_interval = hello.heartbeat_interval
-            self.heartbeat = asyncio.create_task(self.send_heartbeat_loop())
-            self._logger.log_high_priority("Heartbeat started.")
-        except Exception as e:
-            self._logger.log_error(f"Heartbeat Task Error: {type(e).__name__} - {e}")
-    
+        data = await self.receive()
+        hello = HelloEvent.from_dict(data.get('d'))
+        self.heartbeat_interval = hello.heartbeat_interval
+        self.heartbeat = asyncio.create_task(self.send_heartbeat_loop())
+        self._logger.log_high_priority("Heartbeat started.")
+
     async def reconnect(self):
         """Sends RESUME payload to reconnect with the same session ID and sequence number
             as provided by Discord.
@@ -156,20 +142,14 @@ class GatewayClient:
         if self.heartbeat:
             self._logger.log_high_priority(f"Cancelling heartbeat...")
             self.heartbeat.cancel()
-            try:
-                await asyncio.wait_for(self.heartbeat, timeout=3)  # Add timeout to avoid hanging
-            except asyncio.CancelledError:
-                self._logger.log_debug("Heartbeat cancelled by CancelledError.")
-            except asyncio.TimeoutError:
-                self._logger.log_error("Heartbeat cancel timed out.")
-            except Exception as e:
-                self._logger.log_error(f"Unexpected error cancelling heartbeat: {type(e).__name__} - {e}")
+            await asyncio.wait_for(self.heartbeat, timeout=3)  # Add timeout to avoid hanging
             self.heartbeat = None
 
         if self.ws:
-            try:
-                await self.ws.close()
-                self._logger.log_high_priority("WebSocket closed.")
-            except Exception as e:
-                self._logger.log_error(f"Error while closing websocket: {type(e).__name__} - {e}")
+            await self.ws.close()
+            self._logger.log_high_priority("WebSocket closed.")
             self.ws = None
+
+    def is_connected(self):
+        """Helper function to tell whether the websocket is still active."""
+        return self.ws is not None

discord/http.py

@@ -269,24 +269,12 @@ class HTTPClient:
             if now < self.global_reset:
                 await asyncio.sleep(self.global_reset - now)
 
-    async def close_session(self):
-        """Gracefully shuts down all workes and closes aiohttp session."""
-        # Stop all bucket workers
+    async def close_session(self):  
+        """Gracefully shuts down all workes and closes aiohttp session."""      
+        # Stop workers
         for q in self.bucket_queues.values():
             await q.queue.put(self._sentinel)
-
-        # Stop pending worker
         await self.pending_queue.put(self._sentinel)
-
-        # Cancel all tasks except the current one
-        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-        for task in tasks:
-            task.cancel()
-
-        # Wait for tasks to acknowledge cancellation
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-        # Close the aiohttp session
+        
         if self.session and not self.session.closed:
             await self.session.close()
-            self._logger.log_debug("Session closed successfully.")

{scurrypy-0.3.3.dist-info → scurrypy-0.3.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scurrypy
-Version: 0.3.3
+Version: 0.3.4.1
 Summary: Discord API Wrapper in Python
 Author: Furmissile
 Requires-Python: >=3.10

{scurrypy-0.3.3.dist-info → scurrypy-0.3.4.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
 discord/__init__.py,sha256=cETkxHmm0s9YkSJgn-1daQhnbL96fuD7L9SIg2t5vBg,6823
-discord/client.py,sha256=v-phlPbUe1Rr-zg5Posbw_jyv8GxvwmvNbjgAjCZW1Y,13566
+discord/client.py,sha256=LCK6dzQxt6YEy_JiMNpvaJ0WQPRODS_YVvy1SEPeXt8,13582
 discord/client_like.py,sha256=JyJq0XBq0vKuPBJ_ZnYf5yAAuX1zz_2B1TZBQE-BYbQ,473
 discord/config.py,sha256=OH1A2mNKhDlGvQYASEsVUx2pNxP1YQ2a7a7z-IM5xFg,200
 discord/error.py,sha256=AlislRTna554cM6KC0KrwKugzYDYtx_9C8_3QFe4XDc,2070
-discord/gateway.py,sha256=H_WaUrpK8rl3rGlT3qNexpru7R6O6Y6GQPkQcDt_KX8,6555
-discord/http.py,sha256=cGFhGEeNebf1sgSUB4Xfnlj00twWLFi9AwO85gAAUDA,10955
+discord/gateway.py,sha256=1TVUKrd3JovoM4df5-GlMZ0kz15Xls5V48ShXDSlK3Q,5334
+discord/http.py,sha256=BI7bCjedh8zuu5pdOLhI-XwMZfdVj5qP9ZZY6WJqtgo,10511
 discord/intents.py,sha256=Lf2fogFFDqilZeKJv7tcUgKmMW3D7ykK4bBNi-zDzYA,2866
 discord/logger.py,sha256=qAmOc3geCcCCqPhdi61SVWzMDewmM8Q_KWhTcjO46j8,4726
 discord/model.py,sha256=CmuxyoWLWokE_UvCQ9M7U9Cr7JH9R7ULMv9KMwzXjDQ,3105
 discord/dispatch/__init__.py,sha256=m7ixrbNhOV9QRORXPw6LSwxofQMAvLmPFBweBZu9ACc,20
 discord/dispatch/command_dispatcher.py,sha256=pyJOQaZLZYrHUEs6HEWp8XMKTMZX4SBrwTizGKIeUG8,5904
-discord/dispatch/event_dispatcher.py,sha256=tgU5FXJT2NAluT0aIlMhtMjz6hHcJRN6us1vAG639RU,2612
+discord/dispatch/event_dispatcher.py,sha256=1A7Qof_IzTi5_14IMPxIQDpvo3-Sj-X0KZWOuVGH53k,3764
 discord/dispatch/prefix_dispatcher.py,sha256=4mkn3cuXTjdEChbewkbZQqd_sMKm4jePSFKKOPbt12g,2065
 discord/events/__init__.py,sha256=xE8YtJ7NKZkm7MLnohDQIbezh3ColmLR-3BMiZabt3k,18
-discord/events/channel_events.py,sha256=NJbu7oXRdtkUQZ68XbX6fBXINaJmavAkNZStFVA3rzs,1318
-discord/events/guild_events.py,sha256=HA4-loifH5x3j-zAif3H5sJpKX_HbZz4ORgBFvPMe70,852
+discord/events/channel_events.py,sha256=t9UL4JjDqulAP_XepQ8MRMW54pNRqCbIK3M8tauzf9I,1556
+discord/events/guild_events.py,sha256=Ok9tW3tjcwtbiqJgbe-42d9-R3-2RzqmIgBHEP-2Pcc,896
 discord/events/hello_event.py,sha256=O8Ketu_N943cnGaFkGsAHfWhgKXFQCYCqSD3EqdsXjA,225
 discord/events/interaction_events.py,sha256=5hlYOsV1ROiRXISAGCKcZo8vfk6oqiZcNzzZjSteiag,4361
-discord/events/message_events.py,sha256=uovC_n73LuERwjqJHsXqW-IktuIzQTfolQSAzYzlzpc,1411
-discord/events/reaction_events.py,sha256=Mwj3sUWDBl5YKIs4URylXqsrLyMhtQk7d-hF1mYhFbo,2568
+discord/events/message_events.py,sha256=M5xdaJH1zRzdZk0oN0Jykaeu9k09EjgZjeiIT_EkL1A,1475
+discord/events/reaction_events.py,sha256=xx7GD-fqakhJmS-X-HbuAUg9pg6Gqo_KRtLTdPJu7UE,2643
 discord/events/ready_event.py,sha256=c3Pf4ndNYV2byuliADi8pUxpuvKXa9FLKNz_uzIWGso,794
 discord/models/__init__.py,sha256=ZKhFO5eX4GbTRdvi4CU4z2hO-HQU29WZw2x4DujvARY,18
 discord/models/application.py,sha256=2sXtRysUc2TJ40FjdcrWgosmwMrp_h3ybddubQMixKM,924
@@ -48,8 +48,8 @@ discord/resources/guild.py,sha256=Unld1lWY3XynmRHU2FCi3-LA9VNp2thMI2BlILUTTxk,81
 discord/resources/interaction.py,sha256=mr4kLecQpl3AtgnNeqnj3eZIwQ73Clutdi-gnoSMWVU,5237
 discord/resources/message.py,sha256=RtvcCRx0lwW-mHPl3aNYoEvGffrvtpLsQ2fVWckywVI,7527
 discord/resources/user.py,sha256=vk89TnCVi-6ZgbDs_TZTCXrx_NfFS5Q9Wi_itYoaoyg,3085
-scurrypy-0.3.3.dist-info/licenses/LICENSE,sha256=NtspfRMAlryd1Eev4BYi9EFbKhvdmlCJJ2-ADUoEBoI,426
-scurrypy-0.3.3.dist-info/METADATA,sha256=QQHxDvVbl4i51dJwTCr_atvGEXOK9mITtWrK-tdpNZg,2954
-scurrypy-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-scurrypy-0.3.3.dist-info/top_level.txt,sha256=fJkrNbR-_8ubMBUcDEJBcfkpECrvSEmMrNKgvLlQFoM,8
-scurrypy-0.3.3.dist-info/RECORD,,
+scurrypy-0.3.4.1.dist-info/licenses/LICENSE,sha256=NtspfRMAlryd1Eev4BYi9EFbKhvdmlCJJ2-ADUoEBoI,426
+scurrypy-0.3.4.1.dist-info/METADATA,sha256=n5LZHS1N0dlKDDo6DIGXih1tIty503u8UnmTIqTRQ6I,2956
+scurrypy-0.3.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scurrypy-0.3.4.1.dist-info/top_level.txt,sha256=fJkrNbR-_8ubMBUcDEJBcfkpECrvSEmMrNKgvLlQFoM,8
+scurrypy-0.3.4.1.dist-info/RECORD,,