refactor(bot, gateway, http): Remove any unclosed client session messages (#1014)

Author: EepyElvyra

interactions/api/gateway/client.py

@@ -132,13 +132,15 @@ def __init__(
         except RuntimeError:
             self._loop = new_event_loop()
         self._dispatch: Listener = Listener()
+
         self._ratelimiter = (
             WSRateLimit(loop=self._loop) if version_info < (3, 10) else WSRateLimit()
         )
         self.__heartbeater: _Heartbeat = _Heartbeat(
             loop=self._loop if version_info < (3, 10) else None
         )
-        self._http: HTTPClient = HTTPClient(token)
+        self._http: HTTPClient = token
+
         self._client: Optional["ClientWebSocketResponse"] = None
 
         self.__closed: Event = Event(loop=self._loop) if version_info < (3, 10) else Event()
@@ -224,7 +226,8 @@ async def run(self) -> None:
         Handles the client's connection with the Gateway.
         """
 
-        # Credit to NAFF for inspiration for the Gateway logic.
+        if isinstance(self._http, str):
+            self._http = HTTPClient(self._http)
 
         url = await self._http.get_gateway()
         self.ws_url = url
@@ -892,3 +895,11 @@ async def _update_presence(self, presence: ClientPresence) -> None:
         await self._send_packet(payload)
         log.debug(f"UPDATE_PRESENCE: {presence._json}")
         self.__presence = presence
+
+    async def close(self) -> None:
+        """
+        Closes the current connection.
+        """
+        if self._client:
+            await self._client.close()
+        self._closed = True

interactions/api/http/request.py

@@ -18,7 +18,6 @@
 
 __all__ = ("_Request",)
 log: Logger = get_logger("http")
-_session: ClientSession = ClientSession()
 
 
 class _Request:
@@ -48,7 +47,6 @@ class _Request:
     ratelimits: Dict[str, Limiter]  # bucket: Limiter
     buckets: Dict[str, str]  # endpoint: shared_bucket
     _headers: dict
-    _session: ClientSession
     _global_lock: Limiter
 
     def __init__(self, token: str) -> None:
@@ -69,7 +67,7 @@ def __init__(self, token: str) -> None:
             f"Python/{version_info[0]}.{version_info[1]} "
             f"aiohttp/{http_version}",
         }
-        self._session = _session
+        self._session = ClientSession()
         self._global_lock = (
             Limiter(lock=Lock(loop=self._loop)) if version_info < (3, 10) else Limiter(lock=Lock())
         )

interactions/client/bot.py

@@ -67,7 +67,7 @@ class Client:
     :ivar Optional[ClientPresence] _presence: The RPC-like presence shown on an application once connected.
     :ivar str _token: The token of the application used for authentication when connecting.
     :ivar Optional[Dict[str, ModuleType]] _extensions: The "extensions" or cog equivalence registered to the main client.
-    :ivar Application me: The application representation of the client.
+    :ivar Application me?: The application representation of the client.
     """
 
     def __init__(
@@ -76,7 +76,7 @@ def __init__(
         **kwargs,
     ) -> None:
         self._loop: AbstractEventLoop = get_event_loop()
-        self._http: HTTPClient = HTTPClient(token=token)
+        self._http: HTTPClient = token
         self._intents: Intents = kwargs.get("intents", Intents.DEFAULT)
         self._websocket: WSClient = WSClient(token=token, intents=self._intents)
         self._shards: List[Tuple[int]] = kwargs.get("shards", [])
@@ -89,9 +89,9 @@ def __init__(
         self.__command_coroutines = []
         self.__global_commands = {}
         self.__guild_commands = {}
-        self.__id_autocomplete = {}
-        self.me = None
 
+        self.me: Optional[Application] = None
+        self.__id_autocomplete = {}
         if self._default_scope:
             if not isinstance(self._default_scope, list):
                 self._default_scope = [self._default_scope]
@@ -110,9 +110,6 @@ def __init__(
         else:
             self._automate_sync = True
 
-        data = self._loop.run_until_complete(self._http.get_current_bot_information())
-        self.me = Application(**data, _client=self._http)
-
     @property
     def guilds(self) -> List[Guild]:
         """Returns a list of guilds the bot is in."""
@@ -127,12 +124,22 @@ def latency(self) -> float:
 
     def start(self) -> None:
         """Starts the client session."""
+
+        if isinstance(self._http, str):
+            self._http = HTTPClient(self._http)
+
+        data = self._loop.run_until_complete(self._http.get_current_bot_information())
+        self.me = Application(**data, _client=self._http)
+
         try:
             self._loop.run_until_complete(self._ready())
         except (CancelledError, Exception) as e:
+            self._loop.run_until_complete(self._logout())
             raise e from e
         except KeyboardInterrupt:
             log.error("KeyboardInterrupt detected, shutting down the bot.")
+        finally:
+            self._loop.run_until_complete(self._logout())
 
     async def __register_id_autocomplete(self) -> None:  # TODO: make this use ID and not name
         for key in self.__id_autocomplete.keys():
@@ -1475,6 +1482,10 @@ async def modify(
 
         return User(**data)
 
+    async def _logout(self) -> None:
+        await self._websocket.close()
+        await self._http._req.close()
+
 
 # TODO: Implement the rest of cog behaviour when possible.
 class Extension: