scurrypy 0.4__tar.gz → 0.4.2__tar.gz

{scurrypy-0.4 → scurrypy-0.4.2}/PKG-INFO

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

{scurrypy-0.4 → scurrypy-0.4.2}/discord/client.py

@@ -228,9 +228,9 @@ class Client(ClientLike):
             guild_id (int): id of the target guild
         """
         if self._guild_commands.get(guild_id):
-            self._logger.log_info(f"Guild {guild_id} already queued, skipping clear.")
+            self._logger.log_warn(f"Guild {guild_id} already queued, skipping clear.")
             return
-
+        
         self._guild_commands[guild_id] = []
 
     async def _listen(self):
@@ -268,7 +268,7 @@ class Client(ClientLike):
                         self._ws.sequence = None
                         raise ConnectionError("Invalid session.")
                     case 11:
-                        self._logger.log_debug("Heartbeat ACK received")
+                        self._logger.log_info("Heartbeat ACK received")
 
             except asyncio.CancelledError:
                 break
@@ -283,14 +283,15 @@ class Client(ClientLike):
                 raise
             except Exception as e:
                 self._logger.log_error(f"{type(e).__name__} - {e}")
+                self._logger.log_traceback()
                 continue
 
-    async def start(self):
+    async def _start(self):
         """Runs the main lifecycle of the bot.
             Handles connection setup, heartbeat management, event loop, and automatic reconnects.
         """
         try:
-            await self._http.start_session()
+            await self._http.start()
             await self._ws.connect()
             await self._ws.start_heartbeat()
 
@@ -350,7 +351,7 @@ class Client(ClientLike):
 
         # Close HTTP before gateway since it's more important
         self._logger.log_debug("Closing HTTP session...")
-        await self._http.close_session()
+        await self._http.close()
 
         # Then try websocket with short timeout
         try:
@@ -365,11 +366,12 @@ class Client(ClientLike):
             setting up emojis and hooks, and then listens for gateway events.
         """        
         try:
-            asyncio.run(self.start())
+            asyncio.run(self._start())
         except KeyboardInterrupt:
             self._logger.log_debug("Shutdown requested via KeyboardInterrupt.")
         except Exception as e:
             self._logger.log_error(f"{type(e).__name__} {e}")
+            self._logger.log_traceback()
         finally:
             self._logger.log_high_priority("Bot shutting down.")
             self._logger.close()

{scurrypy-0.4 → scurrypy-0.4.2}/discord/dispatch/command_dispatcher.py

@@ -64,7 +64,7 @@ class CommandDispatcher:
             await self._http.request(
                 'PUT', 
                 f"applications/{self.application_id}/guilds/{guild_id}/commands", 
-                [command._to_dict() for command in cmds]
+                data=[command._to_dict() for command in cmds]
             )
     
     async def _register_global_commands(self, commands: list):
@@ -76,7 +76,7 @@ class CommandDispatcher:
 
         global_commands = [command._to_dict() for command in commands]
 
-        await self._http.request('PUT', f"applications/{self.application_id}/commands", global_commands)
+        await self._http.request('PUT', f"applications/{self.application_id}/commands", data=global_commands)
 
     def command(self, name: str, handler):
         """Decorator to register slash commands.
@@ -161,3 +161,4 @@ class CommandDispatcher:
             self._logger.log_info(f"Interaction Event '{name}' Acknowledged.")
         except Exception as e:
             self._logger.log_error(f"Error in interaction '{name}': {e}")
+            self._logger.log_traceback()

{scurrypy-0.4 → scurrypy-0.4.2}/discord/dispatch/event_dispatcher.py

@@ -43,7 +43,7 @@ class EventDispatcher:
         """HTTP session for requests."""
 
         self._logger = client._logger
-        """HTTP session for requests"""
+        """Logger instance to log events."""
 
         self.config = client.config
         """User-defined bot config for persistent data."""

{scurrypy-0.4 → scurrypy-0.4.2}/discord/dispatch/prefix_dispatcher.py

@@ -57,3 +57,4 @@ class PrefixDispatcher:
                     self._logger.log_info(f"Prefix Event '{command}' Acknowledged.")
                 except Exception as e:
                     self._logger.log_error(f"Error in prefix command '{command}': {e}")
+                    self._logger.log_traceback()

{scurrypy-0.4 → scurrypy-0.4.2}/discord/gateway.py

@@ -67,7 +67,6 @@ class GatewayClient:
 
         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
 
@@ -79,7 +78,6 @@ class GatewayClient:
         Args:
             message (dict): the message to send
         """
-        self._logger.log_debug(f"Sending payload: {message}")
         await self.ws.send(json.dumps(message))
 
     async def send_heartbeat_loop(self):
@@ -90,8 +88,7 @@ class GatewayClient:
             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.")
+            self._logger.log_debug(f"Sent HEARTBEAT: {hb_data}")
 
     async def identify(self):
         """Sends the IDENIFY payload (token, intents, connection properties).
@@ -111,7 +108,7 @@ class GatewayClient:
         }
         await self.send(i)
         log_i = self._logger.redact(i)
-        self._logger.log_debug(f"Sending: {log_i}")
+        self._logger.log_debug(f"Sent IDENTIFY: {log_i}")
         self._logger.log_high_priority("Identify sent.")
     
     async def start_heartbeat(self):

scurrypy-0.4.2/discord/http.py

@@ -0,0 +1,217 @@
+import aiohttp
+import aiofiles
+import asyncio
+import json
+
+from typing import Any, Optional
+
+from .logger import Logger
+from .error import DiscordError
+
+class HTTPException(Exception):
+    """Represents an HTTP error response from Discord."""
+    def __init__(self, response: aiohttp.ClientResponse, message: str):
+        self.response = response
+        self.status = response.status
+        self.text = message
+        super().__init__(f"{response.status}: {message}")
+
+class HTTPClient:
+    BASE = "https://discord.com/api/v10"
+    MAX_RETRIES = 3
+
+    def __init__(self, token: str, logger: Logger):
+        self.token = token
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.logger = logger
+        self.global_reset = 0.0
+        self.global_lock = asyncio.Lock()
+        self.endpoint_to_bucket: dict[str, str] = {}
+        self.queues: dict[str, asyncio.Queue] = {}
+        self.workers: dict[str, asyncio.Task] = {}
+
+    async def start(self):
+        """Start the HTTP session."""
+        if not self.session:
+            self.session = aiohttp.ClientSession(
+                headers={"Authorization": f"Bot {self.token}"}
+            )
+
+    async def close(self):
+        """Close the HTTP session."""
+        for task in self.workers.values():
+            task.cancel()
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    async def request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        data: Any | None = None,
+        params: dict | None = None,
+        files: Any | None = None,
+    ):
+        """Enqueues request WRT rate-limit buckets.
+
+        Args:
+            method (str): HTTP method (e.g., POST, GET, DELETE, PATCH, etc.)
+            endpoint (str): Discord endpoint (e.g., /channels/123/messages)
+            data (dict, optional): relevant data
+            params (dict, optional): relevant query params
+            files (list[str], optional): relevant files
+
+        Returns:
+            (Future): future with response
+        """
+        if not self.session:
+            await self.start()
+
+        bucket = self.endpoint_to_bucket.get(endpoint, endpoint)
+        queue = self.queues.setdefault(bucket, asyncio.Queue())
+        future = asyncio.get_event_loop().create_future()
+
+        await queue.put((method, endpoint, data, params, files, future))
+        if bucket not in self.workers:
+            self.workers[bucket] = asyncio.create_task(self._worker(bucket))
+
+        return await future
+
+    async def _worker(self, bucket: str):
+        """Processes request from specific rate-limit bucket."""
+
+        q = self.queues[bucket]
+        while self.session:
+            method, endpoint, data, params, files, future = await q.get()
+            try:
+                result = await self._send(method, endpoint, data, params, files)
+                if not future.done():
+                    future.set_result(result)
+            except Exception as e:
+                if not future.done():
+                    future.set_exception(e)
+            finally:
+                q.task_done()
+
+    async def _send(
+        self,
+        method: str,
+        endpoint: str,
+        data: Any | None,
+        params: dict | None,
+        files: Any | None,
+    ):
+        """Core HTTP request executor.
+
+        Sends a request to Discord, handling JSON payloads, files, query parameters,
+        rate limits, and retries.
+
+        Args:
+            method (str): HTTP method (e.g., 'POST', 'GET', 'DELETE', 'PATCH').
+            endpoint (str): Discord API endpoint (e.g., '/channels/123/messages').
+            data (dict | None, optional): JSON payload to include in the request body.
+            params (dict | None, optional): Query parameters to append to the URL.
+            files (list[str] | None, optional): Files to send with the request.
+
+        Raises:
+            (HTTPException): If the request fails after the maximum number of retries
+                        or receives an error response.
+
+        Returns:
+            (dict | str | None): Parsed JSON response if available, raw text if the
+                            response is not JSON, or None for HTTP 204 responses.
+        """
+
+        url = f"{self.BASE.rstrip('/')}/{endpoint.lstrip('/')}"
+
+        def sanitize_query_params(params: dict | None) -> dict | None:
+            if not params:
+                return None
+            return {k: ('true' if v is True else 'false' if v is False else v)
+                    for k, v in params.items() if v is not None}
+
+        for attempt in range(self.MAX_RETRIES):
+            await self._check_global_limit()
+
+            kwargs = {}
+
+            if files and any(files):
+                payload, headers = await self._make_payload(data, files)
+                kwargs = {"data": payload, "headers": headers}
+            else:
+                kwargs = {"json": data}
+
+            try:
+                async with self.session.request(
+                    method, url, params=sanitize_query_params(params), timeout=15, **kwargs
+                ) as resp:
+                    if resp.status == 429:
+                        data = await resp.json()
+                        retry = float(data.get("retry_after", 1))
+                        if data.get("global"):
+                            self.global_reset = asyncio.get_event_loop().time() + retry
+                        self.logger.log_warn(
+                            f"Rate limited {retry}s ({'global' if data.get('global') else 'bucket'})"
+                        )
+                        await asyncio.sleep(retry + 0.5)
+                        continue
+
+                    if 200 <= resp.status < 300:
+                        if resp.status == 204:
+                            return None
+                        try:
+                            return await resp.json()
+                        except aiohttp.ContentTypeError:
+                            return await resp.text()
+                        
+                    if resp.status == 400:
+                        raise DiscordError(resp.status, await resp.json())
+
+                    text = await resp.text()
+                    raise HTTPException(resp, text)
+
+            except asyncio.TimeoutError:
+                self.logger.log_warn(f"Timeout on {method} {endpoint}, retrying...")
+                continue
+
+        raise HTTPException(resp, f"Failed after {self.MAX_RETRIES} retries")
+
+    async def _check_global_limit(self):
+        """Waits if the global rate-limit is in effect."""
+
+        now = asyncio.get_event_loop().time()
+        if now < self.global_reset:
+            delay = self.global_reset - now
+            self.logger.log_warn(f"Global rate limit active, sleeping {delay:.2f}s")
+            await asyncio.sleep(delay)
+
+    async def _make_payload(self, data: dict, files: list):
+        """Return (data, headers) for aiohttp request — supports multipart.
+
+        Args:
+            data (dict): request data
+            files (list): relevant files
+
+        Returns:
+            (tuple[aiohttp.FormData, dict]): form data and headers
+        """
+        headers = {}
+        if not files:
+            return data, headers
+
+        form = aiohttp.FormData()
+        if data:
+            form.add_field("payload_json", json.dumps(data))
+
+        for idx, file_path in enumerate(files):
+            async with aiofiles.open(file_path, 'rb') as f:
+                data = await f.read()
+            form.add_field(
+                f'files[{idx}]',
+                data,
+                filename=file_path.split('/')[-1],
+                content_type='application/octet-stream'
+            )
+
+        return form, headers

{scurrypy-0.4 → scurrypy-0.4.2}/discord/logger.py

@@ -35,6 +35,7 @@ class Logger:
             """Log file for writing."""
         except Exception as e:
             self.log_error(f"Error {type(e)}: {e}")
+            self.log_traceback()
 
         self.dev_mode = dev_mode
         """If debug logs should be printed."""
@@ -52,6 +53,11 @@ class Logger:
         
         return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
+    def log_traceback(self):
+        if self.dev_mode == True:
+            import traceback
+            self._log("DEBUG", self.DEBUG, traceback.format_exc())
+    
     def _log(self, level: str, color: str, message: str):
         """Internal helper that writes formatted log to both file and console.
 

{scurrypy-0.4 → scurrypy-0.4.2}/discord/resources/channel.py

@@ -148,7 +148,7 @@ class Channel(DataModel):
         if isinstance(message, str):
             message = MessageBuilder(content=message)
 
-        data = await self._http.request("POST", f"/channels/{self.id}/messages", message._to_dict())
+        data = await self._http.request("POST", f"/channels/{self.id}/messages", data=message._to_dict())
 
         return Message.from_dict(data, self._http)
 

{scurrypy-0.4 → scurrypy-0.4.2}/discord/resources/guild.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Optional, TypedDict, Unpack
+from urllib.parse import urlencode
 
 from ..http import HTTPClient
 from ..model import DataModel
@@ -136,7 +137,7 @@ class Guild(DataModel):
         Returns:
             (Channel): the created channel
         """
-        data = await self._http.request('POST', f'/guilds/{self.id}/channels', channel._to_dict())
+        data = await self._http.request('POST', f'/guilds/{self.id}/channels', data=channel._to_dict())
 
         return Channel.from_dict(data, self._http)
 
@@ -233,7 +234,7 @@ class Guild(DataModel):
         Returns:
             (RoleModel): new role data
         """
-        data = await self._http.request('POST', f'/guilds/{self.id}/roles', role._to_dict())
+        data = await self._http.request('POST', f'/guilds/{self.id}/roles', data=role._to_dict())
 
         return RoleModel.from_dict(data)
 
@@ -249,7 +250,7 @@ class Guild(DataModel):
         Returns:
             (RoleModel): role with changes
         """
-        data = await self._http.request('PATCH', f'/guilds/{self.id}/roles/{role_id}', role._to_dict())
+        data = await self._http.request('PATCH', f'/guilds/{self.id}/roles/{role_id}', data=role._to_dict())
 
         return RoleModel.from_dict(data)
     

{scurrypy-0.4 → scurrypy-0.4.2}/discord/resources/interaction.py

@@ -122,7 +122,7 @@ class Interaction(DataModel):
         data = await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content, 
+            data=content, 
             files=[fp.path for fp in message.attachments],
             params=params)
 
@@ -151,7 +151,7 @@ class Interaction(DataModel):
         await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content, 
+            data=content, 
             files=[fp.path for fp in message.attachments])
 
     async def respond_modal(self, modal: ModalBuilder):
@@ -174,4 +174,4 @@ class Interaction(DataModel):
         await self._http.request(
             'POST', 
             f'/interactions/{self.id}/{self.token}/callback', 
-            content)
+            data=content)

{scurrypy-0.4 → scurrypy-0.4.2}/discord/resources/message.py

@@ -68,7 +68,7 @@ class Message(DataModel):
         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)
@@ -88,7 +88,7 @@ class Message(DataModel):
         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)
@@ -110,7 +110,7 @@ class Message(DataModel):
         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):

{scurrypy-0.4 → scurrypy-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scurrypy"
-version = "0.4"
+version = "0.4.2"
 
 description = "Dataclass-driven Discord API Wrapper in Python"
 readme = "README.md"

{scurrypy-0.4 → scurrypy-0.4.2}/scurrypy.egg-info/PKG-INFO

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

scurrypy-0.4/discord/http.py

@@ -1,280 +0,0 @@
-import aiohttp
-import aiofiles
-import asyncio
-import time
-import json
-import ssl
-from dataclasses import dataclass
-from urllib.parse import urlencode
-
-from .logger import Logger
-from .error import DiscordError
-
-ssl_ctx = ssl.create_default_context()
-ssl_ctx.options |= ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3  # Disable old SSL
-
-DISCORD_HTTP_CODES = {
-    200: "Successful Request",
-    201: "Successful Creation",
-    204: "No Content",
-    304: "Not Modified",
-    400: "Bad Request",
-    401: "Missing Authorization",
-    403: "Missing Permission",
-    404: "Resource Not Found",
-    405: "Invalid Method",
-    429: "Rate Limited",
-    502: "Gateway Unavailable"
-}
-
-@dataclass
-class RequestItem:
-    """Data container representing an HTTP request to Discord's API.
-        Used internally by HTTPClient for queuing and processing requests.
-    """
-    method: str
-    """HTTP method (e.g., GET, POST, DELETE, PUT, PATCH)"""
-
-    url: str
-    """Fully qualifying URL for this request."""
-
-    endpoint: str
-    """Endpoint of the URL for this request."""
-
-    data: dict | None
-    """Relevant data for this request."""
-
-    files: list | None
-    """Relevant files for this request."""
-
-    future: asyncio.Future
-    """Track the result of this request."""
-
-class RouteQueue:
-    """Represents a queue of requests for a single rate-limit bucket.
-        Manages task worker that processes requests for that bucket.
-    """
-    def __init__(self):
-        self.queue = asyncio.Queue()
-        """Queue holding RequestItem for this bucket."""
-
-        self.worker = None
-        """Process for executing request for this bucket."""
-
-class HTTPClient:
-    """Handles all HTTP communication with Discord's API
-        including rate-limiting by bucket and globally, async request handling,
-        multipart/form-data file uploads, and error handling/retries.
-    """
-    def __init__(self, token: str, logger: Logger):
-        self.token = token
-        """The bot's token."""
-
-        self._logger = logger
-        """Logger instance to log events."""
-
-        self.session: aiohttp.ClientSession = None
-        """Client session instance."""
-
-        self.global_reset = 0
-        """Global rete limit cooldown if a global rate limit is active."""
-
-        self.global_lock: asyncio.Lock = None
-        """Lock on queues to avoid race conditions."""
-
-        self.pending_queue: asyncio.Queue = None
-        """Queue for requests not yet assigned to bucket."""
-
-        self.pending_worker: asyncio.Task = None
-        """Task processing for the pending queue."""
-
-        self.endpoint_to_bucket: dict[str, str] = {}
-        """Maps endpoints to rate-limit buckets"""
-
-        self.bucket_queues: dict[str, RouteQueue] = {}
-        """Maps endpoints to RouteQueue objects."""
-
-        self._sentinel = object()
-        """Sentinel to terminate session."""
-
-        self.base_url = "https://discord.com/api/v10"
-        """Base URL for discord's API requests."""
-
-    async def start_session(self):
-        """Initializes aiohttp session, queues, locks, and starting pending worker."""
-        self.session = aiohttp.ClientSession()
-        self.pending_queue = asyncio.Queue()
-        self.global_lock = asyncio.Lock()
-        self.pending_worker = asyncio.create_task(self._pending_worker())
-        self._logger.log_debug("Session started.")
-
-    async def request(self, method: str, endpoint: str, data=None, params=None, files=None):
-        """Enqueues request WRT rate-limit buckets.
-
-        Args:
-            method (str): HTTP method (e.g., POST, GET, DELETE, PATCH, etc.)
-            endpoint (str): Discord endpoint (e.g., /channels/123/messages)
-            data (dict, optional): relevant data
-            files (list[str], optional): relevant files
-
-        Returns:
-            (Future): future with response
-        """
-        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" # normalize for single slashes
-        if params:
-            url += f"?{urlencode(params)}"
-
-        future = asyncio.get_event_loop().create_future()
-
-        if endpoint in self.endpoint_to_bucket:
-            bucket = self.endpoint_to_bucket[endpoint]
-            if bucket not in self.bucket_queues:
-                self.bucket_queues[bucket] = RouteQueue()
-                self.bucket_queues[bucket].worker = asyncio.create_task(
-                    self._route_worker(bucket)
-                )
-            await self.bucket_queues[bucket].queue.put(RequestItem(method, url, endpoint, data, files, future))
-        else:
-            await self.pending_queue.put(RequestItem(method, url, endpoint, data, files, future))
-
-        return await future
-
-    async def _pending_worker(self):
-        """Processes requests from global pending queue."""
-        while True:
-            item = await self.pending_queue.get()
-            if item is self._sentinel:
-                self.pending_queue.task_done()
-                break
-            await self._process_request(item)
-            self.pending_queue.task_done()
-
-    async def _route_worker(self, bucket: str):
-        """Processes request from specific rate-limit bucket.
-
-        Args:
-            bucket (str): endpoint
-        """
-        queue = self.bucket_queues[bucket].queue
-        while True:
-            item = await queue.get()
-            if item is self._sentinel:
-                queue.task_done()
-                break
-            await self._process_request(item)
-            queue.task_done()
-
-    async def _process_request(self, item: RequestItem):
-        """Core request execution. Handles headers, payload, files, retries, and bucket assignment.
-
-        Args:
-            item (RequestItem): incoming request
-
-        Raises:
-            DiscordError: discord error object
-        """
-        try:
-            await self._check_global_limit()
-
-            headers = {"Authorization": f"Bot {self.token}"}
-
-            # Build multipart if files exist
-            request_kwargs = {'headers': headers, 'ssl': ssl_ctx}
-
-            if item.files: # only create FormData if files exist
-                form = aiohttp.FormData()
-                form.add_field('payload_json', json.dumps(item.data))
-
-                for idx, file_path in enumerate(item.files):
-                    try:
-                        async with aiofiles.open(file_path, 'rb') as f:
-                            data = await f.read()
-                        form.add_field(
-                            f'files[{idx}]',
-                            data,
-                            filename=file_path.split('/')[-1],
-                            content_type='application/octet-stream'
-                        )
-                    except FileNotFoundError:
-                        self._logger.log_warn(f"File '{file_path}' could not be found.")
-                        break
-
-                request_kwargs['data'] = form
-
-            elif item.data is not None:
-                request_kwargs['json'] = item.data # aiohttp sets Content-Type automatically
-
-            async with self.session.request(item.method, item.url, **request_kwargs) as resp:
-                self._logger.log_debug(f"{item.method} {item.endpoint}: {resp.status} {DISCORD_HTTP_CODES.get(resp.status, 'Unknown Status')}")
-
-                # if triggered rate-limit
-                if resp.status == 429:
-                    data = await resp.json()
-                    retry_after = float(data.get("retry_after", 1))
-                    is_global = data.get("global")
-                    if is_global:
-                        self.global_reset = time.time() + retry_after
-
-                    try:
-                        self._logger.log_warn( f"You are being rate limited on {item.endpoint}. Retrying in {retry_after}s (global={is_global})")
-                        await asyncio.sleep(retry_after + 0.5)
-                    except asyncio.CancelledError:
-                        # shutdown is happening
-                        raise
-
-                    # retry the request
-                    await self._process_request(item)
-                    return
-
-                # if response failed (either lethal or recoverable)
-                elif resp.status not in [200, 201, 204]:
-                    raise DiscordError(resp.status, await resp.json())
-
-                await self._handle_response(item, resp)
-
-                # Handle rate-limit bucket headers
-                bucket = resp.headers.get("X-RateLimit-Bucket")
-                if bucket and item.endpoint not in self.endpoint_to_bucket:
-                    self.endpoint_to_bucket[item.endpoint] = bucket
-                    if bucket not in self.bucket_queues:
-                        self.bucket_queues[bucket] = RouteQueue()
-                        self.bucket_queues[bucket].worker = asyncio.create_task(
-                            self._route_worker(bucket)
-                        )
-
-        except Exception as e:
-            if not item.future.done():
-                item.future.set_exception(e)
-
-    async def _handle_response(self, item: RequestItem, resp: aiohttp.ClientResponse):
-        """Resolves future with parsed JSON/text response.
-
-        Args:
-            item (RequestItem): request data to handle
-            resp (aiohttp.ClientResponse): response for item
-        """
-        if resp.status == 204:
-            item.future.set_result((None, 204))
-        else:
-            try:
-                result = await resp.json()
-            except aiohttp.ContentTypeError:
-                result = await resp.text()
-            item.future.set_result(result)
-
-    async def _check_global_limit(self):
-        """Waits if the global rate-limit is in effect."""
-        async with self.global_lock:
-            now = time.time()
-            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 workers
-        for q in self.bucket_queues.values():
-            await q.queue.put(self._sentinel)
-        await self.pending_queue.put(self._sentinel)
-        
-        if self.session and not self.session.closed:
-            await self.session.close()