Merge pull request #1085 from interactions-py/unstable

chore: Merge unstable to stable

Author: FayeDel

.pre-commit-config.yaml

@@ -29,7 +29,7 @@ repos:
     - id: check-merge-conflict
       name: Merge Conflicts
   - repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 22.8.0
     hooks:
     - id: black
       name: Black Formatting

interactions/api/gateway/client.py

@@ -959,16 +959,18 @@ async def _send_packet(self, data: Dict[str, Any]) -> None:
         """
         _data = dumps(data) if isinstance(data, dict) else data
         packet: str = _data.decode("utf-8") if isinstance(_data, bytes) else _data
+        log.debug(packet)
 
-        if data["op"] != OpCodeType.HEARTBEAT.value:
-            # This is because the ratelimiter limits already accounts for this.
-            await self._ratelimiter.block()
+        async with self.reconnect_lock:  # needs to lock while it reconnects.
 
-        if self._client is not None:  # this mitigates against another edge case.
-            self._last_send = perf_counter()
-            log.debug(packet)
+            if data["op"] != OpCodeType.HEARTBEAT.value:
+                # This is because the ratelimiter limits already accounts for this.
+                await self._ratelimiter.block()
 
-            await self._client.send_str(packet)
+            if self._client is not None:  # this mitigates against another edge case.
+                self._last_send = perf_counter()
+
+                await self._client.send_str(packet)
 
     async def __identify(
         self, shard: Optional[List[Tuple[int]]] = None, presence: Optional[ClientPresence] = None

interactions/api/http/channel.py

@@ -307,3 +307,72 @@ async def delete_stage_instance(self, channel_id: int, reason: Optional[str] = N
         return await self._req.request(
             Route("DELETE", f"/stage-instances/{channel_id}"), reason=reason
         )
+
+    async def create_tag(
+        self,
+        channel_id: int,
+        name: str,
+        emoji_id: Optional[int] = None,
+        emoji_name: Optional[str] = None,
+    ) -> dict:
+        """
+        Create a new tag.
+
+        .. note::
+            Can either have an emoji_id or an emoji_name, but not both.
+            emoji_id is meant for custom emojis, emoji_name is meant for unicode emojis.
+
+        :param channel_id: Channel ID snowflake.
+        :param name: The name of the tag
+        :param emoji_id: The ID of the emoji to use for the tag
+        :param emoji_name: The name of the emoji to use for the tag
+        """
+
+        _dct = {"name": name}
+        if emoji_id:
+            _dct["emoji_id"] = emoji_id
+        if emoji_name:
+            _dct["emoji_name"] = emoji_name
+
+        return await self._req.request(Route("POST", f"/channels/{channel_id}/tags"), json=_dct)
+
+    async def edit_tag(
+        self,
+        channel_id: int,
+        tag_id: int,
+        name: str,
+        emoji_id: Optional[int] = None,
+        emoji_name: Optional[str] = None,
+    ) -> dict:
+        """
+        Update a tag.
+
+        .. note::
+            Can either have an emoji_id or an emoji_name, but not both.
+            emoji_id is meant for custom emojis, emoji_name is meant for unicode emojis.
+
+        :param channel_id: Channel ID snowflake.
+        :param tag_id: The ID of the tag to update.
+        :param name: The new name of the tag
+        :param emoji_id: The ID of the emoji to use for the tag
+        :param emoji_name: The name of the emoji to use for the tag
+        """
+
+        _dct = {"name": name}
+        if emoji_id:
+            _dct["emoji_id"] = emoji_id
+        if emoji_name:
+            _dct["emoji_name"] = emoji_name
+
+        return await self._req.request(
+            Route("PUT", f"/channels/{channel_id}/tags/{tag_id}"), json=_dct
+        )
+
+    async def delete_tag(self, channel_id: int, tag_id: int) -> dict:
+        """
+        Delete a forum tag.
+
+        :param channel_id: Channel ID snowflake.
+        :param tag_id: The ID of the tag to delete
+        """
+        return await self._req.request(Route("DELETE", f"/channels/{channel_id}/tags/{tag_id}"))

interactions/api/http/guild.py

@@ -473,21 +473,21 @@ async def create_guild_ban(
         self,
         guild_id: int,
         user_id: int,
-        delete_message_days: Optional[int] = 0,
+        delete_message_seconds: Optional[int] = 0,
         reason: Optional[str] = None,
     ) -> None:
         """
         Bans a person from the guild, and optionally deletes previous messages sent by them.
 
         :param guild_id: Guild ID snowflake
         :param user_id: User ID snowflake
-        :param delete_message_days: Number of days to delete messages, from 0 to 7. Defaults to 0
+        :param delete_message_seconds: Number of seconds to delete messages for, between 0 and 604800. Default to 0
         :param reason: Optional reason to ban.
         """
 
         return await self._req.request(
             Route("PUT", f"/guilds/{guild_id}/bans/{user_id}"),
-            json={"delete_message_days": delete_message_days},
+            json={"delete_message_seconds": delete_message_seconds},
             reason=reason,
         )
 

interactions/api/http/scheduledEvent.py

@@ -1,7 +1,6 @@
 from typing import List
 
 from ...api.cache import Cache
-from ..models import Snowflake
 from .request import _Request
 from .route import Route
 
@@ -16,15 +15,14 @@ class ScheduledEventRequest:
     def __init__(self) -> None:
         pass
 
-    async def create_scheduled_event(self, guild_id: Snowflake, payload: dict) -> dict:
+    async def create_scheduled_event(self, guild_id: int, payload: dict) -> dict:
         """
         Creates a scheduled event.
 
         :param guild_id: Guild ID snowflake.
         :param payload: The dictionary containing the parameters and values to edit the associated event.
         :return: A dictionary containing the new guild scheduled event object on success.
         """
-        guild_id = int(guild_id)
         valid_keys = (
             "channel_id",
             "name",
@@ -42,50 +40,42 @@ async def create_scheduled_event(self, guild_id: Snowflake, payload: dict) -> di
         )
 
     async def get_scheduled_event(
-        self, guild_id: Snowflake, guild_scheduled_event_id: Snowflake, with_user_count: bool
+        self, guild_id: int, guild_scheduled_event_id: int, with_user_count: bool
     ) -> dict:
         """
         Gets a guild scheduled event.
 
         :param guild_id: Guild ID snowflake.
         :param guild_scheduled_event_id: Guild Scheduled Event ID snowflake.
-        :param with_user_count: A boolean to include number of users subscribed to the associated event, if given.
+        :param with_user_count: Whether the number of users subscribed to the events is returned.
         :return: A dictionary containing the guild scheduled event object on success.
         """
-        guild_id, event_id = int(guild_id), int(guild_scheduled_event_id)
-        params = {}
-        if with_user_count:
-            params["with_user_count"] = str(with_user_count)
 
         return await self._req.request(
             Route(
                 "GET",
                 "/guilds/{guild_id}/scheduled-events/{event_id}",
                 guild_id=guild_id,
-                event_id=event_id,
+                event_id=guild_scheduled_event_id,
             ),
-            params=params,
+            params={"with_user_count": str(with_user_count).lower()},
         )
 
-    async def get_scheduled_events(self, guild_id: Snowflake, with_user_count: bool) -> List[dict]:
+    async def get_scheduled_events(self, guild_id: int, with_user_count: bool) -> List[dict]:
         """
         Gets all guild scheduled events in a guild.
 
         :param guild_id: Guild ID snowflake.
-        :param with_user_count: A boolean to include number of users subscribed to the associated event, if given.
+        :param with_user_count: Whether the number of users subscribed to the associated event is returned.
         :return: A List of a dictionary containing the guild scheduled event objects on success.
         """
-        guild_id = int(guild_id)
-        params = {}
-        if with_user_count:
-            params["with_user_count"] = with_user_count
-
         return await self._req.request(
-            Route("GET", "/guilds/{guild_id}/scheduled-events", guild_id=guild_id), params=params
+            Route("GET", "/guilds/{guild_id}/scheduled-events", guild_id=guild_id),
+            params={"with_user_count": str(with_user_count).lower()},
         )
 
     async def modify_scheduled_event(
-        self, guild_id: Snowflake, guild_scheduled_event_id: Snowflake, payload: dict
+        self, guild_id: int, guild_scheduled_event_id: int, payload: dict
     ) -> dict:
         """
         Modifies a scheduled event.
@@ -95,7 +85,6 @@ async def modify_scheduled_event(
         :param payload: The dictionary containing the parameters and values to edit the associated event.
         :return: A dictionary containing the updated guild scheduled event object on success.
         """
-        guild_id, event_id = int(guild_id), int(guild_scheduled_event_id)
         valid_keys = (
             "channel_id",
             "name",
@@ -112,40 +101,37 @@ async def modify_scheduled_event(
                 "PATCH",
                 "/guilds/{guild_id}/scheduled-events/{event_id}",
                 guild_id=guild_id,
-                event_id=event_id,
+                event_id=guild_scheduled_event_id,
             ),
             json=data,
         )
 
-    async def delete_scheduled_event(
-        self, guild_id: Snowflake, guild_scheduled_event_id: Snowflake
-    ) -> None:
+    async def delete_scheduled_event(self, guild_id: int, guild_scheduled_event_id: int) -> None:
         """
         Deletes a guild scheduled event.
 
         :param guild_id: Guild ID snowflake.
         :param guild_scheduled_event_id: Guild Scheduled Event ID snowflake.
         :return: Nothing on success.
         """
-        guild_id, event_id = int(guild_id), int(guild_scheduled_event_id)
 
         return await self._req.request(
             Route(
                 "DELETE",
                 "/guilds/{guild_id}/scheduled-events/{event_id}",
                 guild_id=guild_id,
-                event_id=event_id,
+                event_id=guild_scheduled_event_id,
             )
         )
 
     async def get_scheduled_event_users(
         self,
-        guild_id: Snowflake,
-        guild_scheduled_event_id: Snowflake,
+        guild_id: int,
+        guild_scheduled_event_id: int,
         limit: int = 100,
         with_member: bool = False,
-        before: Snowflake = None,
-        after: Snowflake = None,
+        before: int = None,
+        after: int = None,
     ) -> dict:
         """
         Get the registered users of a scheduled event.
@@ -158,22 +144,21 @@ async def get_scheduled_event_users(
         :param after: Considers only users after given user ID snowflake. Defaults to None.
         :return: Returns a list of guild scheduled event user objects on success.
         """
-        guild_id, event_id = int(guild_id), int(guild_scheduled_event_id)
         params = {
             "limit": limit,
             "with_member": with_member,
         }
         if before:
-            params["before"] = int(before)
+            params["before"] = before
         if after:
-            params["after"] = int(after)
+            params["after"] = after
 
         return await self._req.request(
             Route(
                 "GET",
                 "/guilds/{guild_id}/scheduled-events/{event_id}/users",
                 guild_id=guild_id,
-                event_id=event_id,
+                event_id=guild_scheduled_event_id,
             ),
             params=params,
         )

interactions/api/http/thread.py

@@ -1,7 +1,11 @@
 from typing import Dict, List, Optional
 
+from aiohttp import MultipartWriter
+
 from ...api.cache import Cache
+from ...utils.missing import MISSING
 from ..models.channel import Channel
+from ..models.misc import File
 from .request import _Request
 from .route import Route
 
@@ -189,3 +193,62 @@ async def create_thread(
             self.cache[Channel].add(Channel(**request))
 
         return request
+
+    async def create_thread_in_forum(
+        self,
+        channel_id: int,
+        name: str,
+        auto_archive_duration: int,
+        message_payload: dict,
+        applied_tags: List[str] = None,
+        files: Optional[List[File]] = MISSING,
+        rate_limit_per_user: Optional[int] = None,
+        reason: Optional[str] = None,
+    ) -> dict:
+        """
+        From a given Forum channel, create a Thread with a message to start with.
+
+        :param channel_id: The ID of the channel to create this thread in
+        :param name: The name of the thread
+        :param auto_archive_duration: duration in minutes to automatically archive the thread after recent activity,
+            can be set to: 60, 1440, 4320, 10080
+        :param message_payload: The payload/dictionary contents of the first message in the forum thread.
+        :param applied_tags: List of tag ids that can be applied to the forum, if any.
+        :param files: An optional list of files to send attached to the message.
+        :param rate_limit_per_user: Seconds a user has to wait before sending another message (0 to 21600), if given.
+        :param reason: An optional reason for the audit log
+        :return: Returns a Thread in a Forum object with a starting Message.
+        """
+        query = {"use_nested_fields": 1}
+
+        payload = {"name": name, "auto_archive_duration": auto_archive_duration}
+        if rate_limit_per_user:
+            payload["rate_limit_per_user"] = rate_limit_per_user
+        if applied_tags:
+            payload["applied_tags"] = applied_tags
+
+        data = None
+        if files is not MISSING and len(files) > 0:
+
+            data = MultipartWriter("form-data")
+            part = data.append_json(payload)
+            part.set_content_disposition("form-data", name="payload_json")
+            payload = None
+
+            for id, file in enumerate(files):
+                part = data.append(
+                    file._fp,
+                )
+                part.set_content_disposition(
+                    "form-data", name=f"files[{str(id)}]", filename=file._filename
+                )
+        else:
+            payload.update(message_payload)
+
+        return await self._req.request(
+            Route("POST", f"/channels/{channel_id}/threads"),
+            json=payload,
+            data=data,
+            params=query,
+            reason=reason,
+        )