chore: catchup branch to stable.

* fix!: make context not required

* fix!: remove requirement of reason in helper methods

* Update gateway.py

feat!(gateway): Introduce proper reconnection without close. (#567)

It may introduce a runtime error however.

docs: add migration docs for 4.1

docs: detail message content intent in migration

Author: EepyElvyra

docs/migration.rst

@@ -20,6 +20,45 @@ will need it appended as a key-word argument. The example below shows this chang
 
     # 4.0.2
     ...
-    channel = interactions.Channel(**data, _state=bot.http)
+    channel = interactions.Channel(**data, _client=bot.http)
 
 This change was added in favor for being able to use endpoints in an abstracted state.
+
+4.0.2 → 4.1.0
+~~~~~~~~~~~~~~~
+
+``4.1.0`` introduces numerous breaking changes that affect the bot developers' ability to work with mainly modifying
+the way our Gateway processes information, as well as supplying a ``reason`` argument to ``HTTPClient``-based methods.
+
+In this version, you are no longer required to give a ``reason`` for every HTTP request. You can instead send it as an optional,
+which will work to keep any existing modifications of our codebase from breaking.
+
+Additionally, modifying the way information is dispatched from the Gateway must be done like this now:
+
+.. code-block:: python
+
+    import interactions
+
+    class ExtendedWebSocketClient(interactions.WebSocketClient):
+        def _dispatch_event(self, event: str, data: dict):
+            super()._dispatch_event(event, data)
+
+            if event != "TYPING_START" and event == "INTERACTION_CREATE":
+                ... # run your special interaction dispatch rules here.
+
+We recommend that working in correspondance with this, you should be making use of our ``interactions.ext`` SDK framework.
+
+A slight, yet another breaking change we made was dundering numerous attributes in our internal models.
+You will now need to refer to the client's HTTP object as ``_http`` instead of ``http``. In order to view
+the full list of these, we highly encourage you to view the documentation readily available.
+
+The last, and most major change is the introduction of the ``MESSAGE_CONTENT`` privileged intent in the library.
+Because of ``4.1.0`` using version 10 of the Discord API, this intent is now required for reading all message
+content. In order to make sure your bot works still, you will need to enable this intent in your bot's developer
+portal and add the intent to your current intents when connecting:
+
+.. code-block:: python
+
+    from interactions import Client, Intents
+
+    bot = Client("TOKEN", intents=Intents.DEFAULT | Intents.MEESAGE_CONTENT)

interactions/api/gateway.py

@@ -165,7 +165,7 @@ async def __restart(self):
         if self.__task:
             self.__task: Task
             self.__task.cancel()
-        await self._client.close()
+        self._client = None  # clear pending waits
         self.__heartbeater.event.clear()
         await self._establish_connection()
 
@@ -199,6 +199,10 @@ async def _establish_connection(
 
                 if stream is None:
                     continue
+                if self._client is None:
+                    await self._establish_connection()
+                    break
+
                 if self._client.close_code in range(4010, 4014) or self._client.close_code == 4004:
                     raise GatewayException(self._client.close_code)
 
@@ -230,6 +234,10 @@ async def _handle_connection(
             if op == OpCodeType.HELLO:
                 self.__heartbeater.delay = data["heartbeat_interval"]
                 self.__heartbeater.event.set()
+
+                if self.__task:
+                    self.__task.cancel()  # so we can reduce redundant heartbeat bg tasks.
+
                 self.__task = ensure_future(self._manage_heartbeat())
 
                 if not self.session_id:
@@ -246,12 +254,17 @@ async def _handle_connection(
             if op in (OpCodeType.INVALIDATE_SESSION, OpCodeType.RECONNECT):
                 log.debug("INVALID_SESSION/RECONNECT")
 
-                if data and op != OpCodeType.RECONNECT:
+                # if data and op != OpCodeType.RECONNECT:
+                #    self.session_id = None
+                #    self.sequence = None
+                # self._closed = True
+
+                if bool(data) is False and op == OpCodeType.INVALIDATE_SESSION:
                     self.session_id = None
-                    self.sequence = None
-                    self._closed = True
 
                 await self.__restart()
+        elif event == "RESUMED":
+            log.debug(f"RESUMED (session_id: {self.session_id}, seq: {self.sequence})")
         elif event == "READY":
             self._ready = data
             self.session_id = data["session_id"]
@@ -342,7 +355,7 @@ def _dispatch_event(self, event: str, data: dict) -> None:
 
                         if _context.data._json.get("options"):
                             for option in _context.data.options:
-                                __name, _value = self.__sub_command_context(option)
+                                __name, _value = self.__sub_command_context(option, _context)
                                 _name += f"_{__name}" if __name else ""
 
                                 if _value:
@@ -399,7 +412,7 @@ def __contextualize(self, data: dict) -> object:
             return context(**data)
 
     def __sub_command_context(
-        self, data: Union[dict, Option], context: object = MISSING
+        self, data: Union[dict, Option], context: object
     ) -> Union[Tuple[str], dict]:
         """
         Checks if an application command schema has sub commands
@@ -515,6 +528,9 @@ def __option_type_context(self, context: object, type: int) -> dict:
             }
         return _resolved
 
+    async def restart(self):
+        await self.__restart()
+
     @property
     async def __receive_packet_stream(self) -> Optional[Dict[str, Any]]:
         """
@@ -523,6 +539,7 @@ async def __receive_packet_stream(self) -> Optional[Dict[str, Any]]:
         :return: The packet stream.
         :rtype: Optional[Dict[str, Any]]
         """
+
         packet: WSMessage = await self._client.receive()
         return loads(packet.data) if packet and isinstance(packet.data, str) else None
 

interactions/api/gateway.pyi

@@ -78,3 +78,4 @@ class WebSocketClient:
     def shard(self) -> None: ...
     @property
     def presence(self) -> None: ...
+    async def restart(self): ...