refactor: better Gateway for reconnection control. (#451)

* refactor: beginning Gateway connection rewrite.

* feat: add `UnavailableGuild` model object.

* refactor: Abstract away from gateway headers, utilise internal events/data to daemonise, correct some attributes.

* feat!: Implement somewhat working reconnection, reinclude dispatching, fix heartbeat packet sending

This still doesn't work properly, it just hangs later than stable.

* refactor: Switch heartbeater bool back to Event obj.

* refactor: correclty parse reconnection logic.

* docs: clarify new gateway structure.

* fix: Fix import typos and reordered import references

* fix: Fix http loop invocation for py 3.10, add _ready to gateway slot.

* fix: Fix event loop object creation on py 3.10

* fix: Fix await runtime error and close code checking.

* refactor: reset heartbeater on death, read from closed/closing states.

* ci: correct from checks.

* refactor: `wait` on the event instead of `sleep` which targets the whole loop

* fix: Switch asyncio loop delay on sending multiple heartbeat sending.

Co-authored-by: DeltaXWizard <33706469+deltaxwizard@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

interactions/api/gateway.py

@@ -1,51 +1,71 @@
-from asyncio import AbstractEventLoop
-from threading import Event, Thread
-from typing import Any, List, Optional, Union
+from asyncio import (
+    AbstractEventLoop,
+    Event,
+    Task,
+)
+from logging import Logger
+from typing import Any, Dict, List, Optional, Tuple
 
+from aiohttp import ClientWebSocketResponse
+
+from ..api.models.gw import Presence
+from ..base import get_logger
+from ..models.misc import MISSING
 from .dispatch import Listener
 from .http import HTTPClient
-from .models.gw import Presence
 from .models.flags import Intents
 
-class Heartbeat(Thread):
-    ws: Any
-    interval: Union[int, float]
+log: Logger = get_logger("gateway")
+
+__all__ = ("_Heartbeat", "WebSocketClient")
+
+class _Heartbeat:
     event: Event
-    def __init__(self, ws: Any, interval: int) -> None: ...
-    def run(self) -> None: ...
-    def stop(self) -> None: ...
+    delay: float
+    def __init__(self, loop: AbstractEventLoop) -> None: ...
 
-class WebSocket:
-    intents: Intents
-    loop: AbstractEventLoop
-    dispatch: Listener
-    session: Any
-    session_id: Optional[int]
-    sequence: Optional[int]
-    keep_alive: Optional[Heartbeat]
-    closed: bool
-    http: Optional[HTTPClient]
-    options: dict
+class WebSocketClient:
+    _loop: AbstractEventLoop
+    _dispatch: Listener
+    _http: HTTPClient
+    _client: Optional[ClientWebSocketResponse]
+    _closed: bool
+    _options: dict
+    _intents: Intents
+    _ready: dict
+    __heartbeater: _Heartbeat
+    __shard: Optional[List[Tuple[int]]]
+    __presence: Optional[Presence]
+    __task: Optional[Task]
+    session_id: int
+    sequence: str
     def __init__(
         self,
+        token: str,
         intents: Intents,
-        session_id: Optional[int] = None,
-        sequence: Optional[int] = None,
+        session_id: Optional[int] = MISSING,
+        sequence: Optional[int] = MISSING,
     ) -> None: ...
-    async def recv(self) -> Optional[Any]: ...
-    async def connect(
-        self, token: str, shard: Optional[List[int]] = None, presence: Optional[Presence] = None
+    async def _manage_heartbeat(self) -> None: ...
+    async def __restart(self): ...
+    async def _establish_connection(
+        self, shard: Optional[List[Tuple[int]]] = MISSING, presence: Optional[Presence] = MISSING
     ) -> None: ...
-    async def handle_connection(
-        self, stream: dict, shard: Optional[List[int]] = None, presence: Optional[Presence] = None
+    async def _handle_connection(
+        self,
+        stream: Dict[str, Any],
+        shard: Optional[List[Tuple[int]]] = MISSING,
+        presence: Optional[Presence] = MISSING,
     ) -> None: ...
-    def handle_dispatch(self, event: str, data: dict) -> None: ...
-    def contextualize(self, data: dict) -> object: ...
-    async def send(self, data: Union[str, dict]) -> None: ...
-    async def identify(
-        self, shard: Optional[List[int]] = None, presence: Optional[Presence] = None
+    @property
+    async def __receive_packet_stream(self) -> Optional[Dict[str, Any]]: ...
+    async def _send_packet(self, data: Dict[str, Any]) -> None: ...
+    async def __identify(
+        self, shard: Optional[List[Tuple[int]]] = None, presence: Optional[Presence] = None
     ) -> None: ...
-    async def resume(self) -> None: ...
-    async def heartbeat(self) -> None: ...
-    def check_sub_auto(self, option) -> tuple: ...
-    def check_sub_command(self, option) -> dict: ...
+    async def __resume(self) -> None: ...
+    async def __heartbeat(self) -> None: ...
+    @property
+    def shard(self) -> None: ...
+    @property
+    def presence(self) -> None: ...

interactions/api/gateway.pyi

@@ -129,6 +129,26 @@ def __init__(self, **kwargs):
         self.channel_id = Snowflake(self.channel_id) if self._json.get("channel_id") else None
 
 
+class UnavailableGuild(DictSerializerMixin):
+    """
+    A class object representing how a guild that is unavailable.
+
+    .. note::
+        This object only seems to show up during the connection process
+        of the client to the Gateway when the ``READY`` event is dispatched.
+        This event will pass fields with ``guilds`` where this becomes
+        present.
+
+    :ivar Snowflake id: The ID of the unavailable guild.
+    :ivar bool unavailable: Whether the guild is unavailable or not.
+    """
+
+    __slots__ = ("_json", "id", "unavailable")
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
 class Guild(DictSerializerMixin):
     """
     A class object representing how a guild is registered.

interactions/api/models/guild.py

@@ -45,6 +45,12 @@ class StageInstance(DictSerializerMixin):
     discoverable_disabled: bool
     def __init__(self, **kwargs): ...
 
+class UnavailableGuild(DictSerializerMixin):
+    _json: dict
+    id: Snowflake
+    unavailable: bool
+    def __init__(self, **kwargs): ...
+
 class Guild(DictSerializerMixin):
     _json: dict
     _client: HTTPClient

interactions/api/models/guild.pyi

@@ -1,12 +1,10 @@
 from datetime import datetime
 
-from interactions.api.models.channel import Channel, ThreadMember
-from interactions.api.models.presence import PresenceActivity
-from interactions.models.command import Permission
-
+from .channel import Channel, ThreadMember
 from .member import Member
 from .message import Emoji, Sticker
 from .misc import ClientStatus, DictSerializerMixin, Snowflake
+from .presence import PresenceActivity
 from .role import Role
 from .user import User
 
@@ -32,14 +30,15 @@ def __init__(self, **kwargs):
         )
         self.guild_id = Snowflake(self.guild_id) if self._json.get("guild_id") else None
         self.id = Snowflake(self.id) if self._json.get("id") else None
-        self.permissions = (
-            [
-                Permission(**_permission) if isinstance(_permission, dict) else _permission
-                for _permission in self._json.get("permissions")
-            ]
-            if self._json.get("permissions")
-            else None
-        )
+        # TODO: fix the circular import hell from this.
+        # self.permissions = (
+        #     [
+        #         Permission(**_permission) if isinstance(_permission, dict) else _permission
+        #         for _permission in self._json.get("permissions")
+        #     ]
+        #     if self._json.get("permissions")
+        #     else None
+        # )
 
 
 class ChannelPins(DictSerializerMixin):

interactions/api/models/gw.py

@@ -12,7 +12,7 @@
 from .api.cache import Cache
 from .api.cache import Item as Build
 from .api.error import InteractionException, JSONException
-from .api.gateway import WebSocket
+from .api.gateway import WebSocketClient
 from .api.http import HTTPClient
 from .api.models.flags import Intents
 from .api.models.guild import Guild
@@ -36,7 +36,7 @@ class Client:
 
     :ivar AbstractEventLoop _loop: The asynchronous event loop of the client.
     :ivar HTTPClient _http: The user-facing HTTP connection to the Web API, as its own separate client.
-    :ivar WebSocket _websocket: An object-orientation of a websocket server connection to the Gateway.
+    :ivar WebSocketClient _websocket: An object-orientation of a websocket server connection to the Gateway.
     :ivar Intents _intents: The Gateway intents of the application. Defaults to ``Intents.DEFAULT``.
     :ivar Optional[List[Tuple[int]]] _shard: The list of bucketed shards for the application's connection.
     :ivar Optional[Presence] _presence: The RPC-like presence shown on an application once connected.
@@ -77,7 +77,7 @@ def __init__(
         self._loop = get_event_loop()
         self._http = HTTPClient(token=token)
         self._intents = kwargs.get("intents", Intents.DEFAULT)
-        self._websocket = WebSocket(intents=self._intents)
+        self._websocket = WebSocketClient(token=token, intents=self._intents)
         self._shard = kwargs.get("shards", [])
         self._presence = kwargs.get("presence")
         self._token = token
@@ -104,10 +104,10 @@ def start(self) -> None:
 
     def __register_events(self) -> None:
         """Registers all raw gateway events to the known events."""
-        self._websocket.dispatch.register(self.__raw_socket_create)
-        self._websocket.dispatch.register(self.__raw_channel_create, "on_channel_create")
-        self._websocket.dispatch.register(self.__raw_message_create, "on_message_create")
-        self._websocket.dispatch.register(self.__raw_guild_create, "on_guild_create")
+        self._websocket._dispatch.register(self.__raw_socket_create)
+        self._websocket._dispatch.register(self.__raw_channel_create, "on_channel_create")
+        self._websocket._dispatch.register(self.__raw_message_create, "on_message_create")
+        self._websocket._dispatch.register(self.__raw_guild_create, "on_guild_create")
 
     async def __compare_sync(self, data: dict, pool: List[dict]) -> bool:
         """
@@ -302,8 +302,8 @@ async def _ready(self) -> None:
 
     async def _login(self) -> None:
         """Makes a login with the Discord API."""
-        while not self._websocket.closed:
-            await self._websocket.connect(self._token, self._shard, self._presence)
+        while not self._websocket._closed:
+            await self._websocket._establish_connection(self._shard, self._presence)
 
     def event(self, coro: Coroutine, name: Optional[str] = MISSING) -> Callable[..., Any]:
         """
@@ -317,7 +317,7 @@ def event(self, coro: Coroutine, name: Optional[str] = MISSING) -> Callable[...,
         :return: A callable response.
         :rtype: Callable[..., Any]
         """
-        self._websocket.dispatch.register(coro, name if name is not MISSING else coro.__name__)
+        self._websocket._dispatch.register(coro, name if name is not MISSING else coro.__name__)
         return coro
 
     def __check_command(

interactions/client.py

@@ -3,7 +3,7 @@ from types import ModuleType
 from typing import Any, Callable, Coroutine, Dict, List, NoReturn, Optional, Tuple, Union
 
 from .api.cache import Cache
-from .api.gateway import WebSocket
+from .api.gateway import WebSocketClient
 from .api.http import HTTPClient
 from .api.models.flags import Intents
 from .api.models.guild import Guild
@@ -21,7 +21,7 @@ _cache: Optional[Cache] = None
 class Client:
     _loop: AbstractEventLoop
     _http: HTTPClient
-    _websocket: WebSocket
+    _websocket: WebSocketClient
     _intents: Intents
     _shard: Optional[List[Tuple[int]]]
     _presence: Optional[Presence]

interactions/client.pyi

@@ -13,18 +13,9 @@ async def on_ready():
     print("bot is now online.")
 
 
-@bot.event
-async def on_message_create(message: interactions.Message):
-    await bot._http.send_message(channel_id=852402668294766615, content=message.content)
-
-
-@bot.command(
-    type=interactions.ApplicationCommandType.MESSAGE,
-    name="simple testing command",
-    scope=852402668294766612,
-)
-async def simple_testing_command(ctx):
-    await ctx.send("Hello world!")
+@bot.command(name="intent", description="h")
+async def intent(ctx):
+    await ctx.send("hola")
 
 
 bot.start()