Merge branch 'master' of https://github.com/Rapptz/discord.py

Author: Soheab

MANIFEST.in

@@ -1,5 +1,5 @@
 include README.rst
 include LICENSE
 include requirements.txt
-include discord/bin/*.dll
+include discord/bin/*
 include discord/py.typed

discord/abc.py

@@ -60,6 +60,7 @@
 from .voice_client import VoiceClient, VoiceProtocol
 from .sticker import GuildSticker, StickerItem
 from . import utils
+from .flags import InviteFlags
 
 __all__ = (
     'Snowflake',
@@ -1257,6 +1258,7 @@ async def create_invite(
         target_type: Optional[InviteTarget] = None,
         target_user: Optional[User] = None,
         target_application_id: Optional[int] = None,
+        guest: bool = False,
     ) -> Invite:
         """|coro|
 
@@ -1295,6 +1297,10 @@ async def create_invite(
             The id of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.
 
             .. versionadded:: 2.0
+        guest: :class:`bool`
+            Whether the invite is a guest invite.
+
+            .. versionadded:: 2.6
 
         Raises
         -------
@@ -1312,6 +1318,11 @@ async def create_invite(
         if target_type is InviteTarget.unknown:
             raise ValueError('Cannot create invite with an unknown target type')
 
+        flags: Optional[InviteFlags] = None
+        if guest:
+            flags = InviteFlags._from_value(0)
+            flags.guest = True
+
         data = await self._state.http.create_invite(
             self.id,
             reason=reason,
@@ -1322,6 +1333,7 @@ async def create_invite(
             target_type=target_type.value if target_type else None,
             target_user_id=target_user.id if target_user else None,
             target_application_id=target_application_id,
+            flags=flags.value if flags else None,
         )
         return Invite.from_incomplete(data=data, state=self._state)
 

discord/activity.py

@@ -418,7 +418,7 @@ def __str__(self) -> str:
         return str(self.name)
 
     def __repr__(self) -> str:
-        return f'<Game name={self.name!r}>'
+        return f'<Game name={self.name!r} platform={self.platform!r}>'
 
     def to_dict(self) -> Dict[str, Any]:
         timestamps: Dict[str, Any] = {}
@@ -514,7 +514,7 @@ def __str__(self) -> str:
         return str(self.name)
 
     def __repr__(self) -> str:
-        return f'<Streaming name={self.name!r}>'
+        return f'<Streaming name={self.name!r} platform={self.platform!r}>'
 
     @property
     def twitch_name(self) -> Optional[str]:

discord/app_commands/commands.py

@@ -687,9 +687,9 @@ def __init__(
 
         self._params: Dict[str, CommandParameter] = _extract_parameters_from_callback(callback, callback.__globals__)
         self.checks: List[Check] = getattr(callback, '__discord_app_commands_checks__', [])
-        self._guild_ids: Optional[List[int]] = guild_ids or getattr(
-            callback, '__discord_app_commands_default_guilds__', None
-        )
+        self._guild_ids: Optional[List[int]] = guild_ids
+        if self._guild_ids is None:
+            self._guild_ids = getattr(callback, '__discord_app_commands_default_guilds__', None)
         self.default_permissions: Optional[Permissions] = getattr(
             callback, '__discord_app_commands_default_permissions__', None
         )
@@ -1250,7 +1250,9 @@ def __init__(
         self._param_name = param
         self._annotation = annotation
         self.module: Optional[str] = callback.__module__
-        self._guild_ids = guild_ids or getattr(callback, '__discord_app_commands_default_guilds__', None)
+        self._guild_ids = guild_ids
+        if self._guild_ids is None:
+            self._guild_ids = getattr(callback, '__discord_app_commands_default_guilds__', None)
         self.on_error: Optional[UnboundError] = None
         self.default_permissions: Optional[Permissions] = getattr(
             callback, '__discord_app_commands_default_permissions__', None
@@ -1587,7 +1589,9 @@ def __init__(
 
         self._attr: Optional[str] = None
         self._owner_cls: Optional[Type[Any]] = None
-        self._guild_ids: Optional[List[int]] = guild_ids or getattr(cls, '__discord_app_commands_default_guilds__', None)
+        self._guild_ids: Optional[List[int]] = guild_ids
+        if self._guild_ids is None:
+            self._guild_ids = getattr(cls, '__discord_app_commands_default_guilds__', None)
 
         if default_permissions is MISSING:
             if cls.__discord_app_commands_default_permissions__ is MISSING:
@@ -2367,6 +2371,9 @@ def guilds(*guild_ids: Union[Snowflake, int]) -> Callable[[T], T]:
     specified by this decorator become the default guilds that it's added to rather
     than being a global command.
 
+    If no arguments are given, then the command will not be synced anywhere. This may
+    be modified later using the :meth:`CommandTree.add_command` method.
+
     .. note::
 
         Due to an implementation quirk and Python limitation, if this is used in conjunction

discord/app_commands/installs.py

@@ -57,6 +57,9 @@ def __init__(self, *, guild: Optional[bool] = None, user: Optional[bool] = None)
         self._guild: Optional[bool] = guild
         self._user: Optional[bool] = user
 
+    def __repr__(self):
+        return f'<AppInstallationType guild={self.guild!r} user={self.user!r}>'
+
     @property
     def guild(self) -> bool:
         """:class:`bool`: Whether the integration is a guild install."""
@@ -142,6 +145,9 @@ def __init__(
         self._dm_channel: Optional[bool] = dm_channel
         self._private_channel: Optional[bool] = private_channel
 
+    def __repr__(self) -> str:
+        return f'<AppCommandContext guild={self.guild!r} dm_channel={self.dm_channel!r} private_channel={self.private_channel!r}>'
+
     @property
     def guild(self) -> bool:
         """:class:`bool`: Whether the context allows usage in a guild."""

discord/app_commands/models.py

@@ -26,7 +26,7 @@
 from datetime import datetime
 
 from .errors import MissingApplicationID
-from ..flags import AppCommandContext, AppInstallationType
+from ..flags import AppCommandContext, AppInstallationType, ChannelFlags
 from .translator import TranslationContextLocation, TranslationContext, locale_str, Translator
 from ..permissions import Permissions
 from ..enums import (
@@ -575,6 +575,35 @@ class AppCommandChannel(Hashable):
         the application command in that channel.
     guild_id: :class:`int`
         The guild ID this channel belongs to.
+    category_id: Optional[:class:`int`]
+        The category channel ID this channel belongs to, if applicable.
+
+        .. versionadded:: 2.6
+    topic: Optional[:class:`str`]
+        The channel's topic. ``None`` if it doesn't exist.
+
+        .. versionadded:: 2.6
+    position: :class:`int`
+        The position in the channel list. This is a number that starts at 0. e.g. the
+        top channel is position 0.
+
+        .. versionadded:: 2.6
+    last_message_id: Optional[:class:`int`]
+        The last message ID of the message sent to this channel. It may
+        *not* point to an existing or valid message.
+
+        .. versionadded:: 2.6
+    slowmode_delay: :class:`int`
+        The number of seconds a member must wait between sending messages
+        in this channel. A value of ``0`` denotes that it is disabled.
+        Bots and users with :attr:`~discord.Permissions.manage_channels` or
+        :attr:`~discord.Permissions.manage_messages` bypass slowmode.
+
+        .. versionadded:: 2.6
+    nsfw: :class:`bool`
+        If the channel is marked as "not safe for work" or "age restricted".
+
+        .. versionadded:: 2.6
     """
 
     __slots__ = (
@@ -583,6 +612,14 @@ class AppCommandChannel(Hashable):
         'name',
         'permissions',
         'guild_id',
+        'topic',
+        'nsfw',
+        'position',
+        'category_id',
+        'slowmode_delay',
+        'last_message_id',
+        '_last_pin',
+        '_flags',
         '_state',
     )
 
@@ -599,6 +636,14 @@ def __init__(
         self.type: ChannelType = try_enum(ChannelType, data['type'])
         self.name: str = data['name']
         self.permissions: Permissions = Permissions(int(data['permissions']))
+        self.topic: Optional[str] = data.get('topic')
+        self.position: int = data.get('position') or 0
+        self.nsfw: bool = data.get('nsfw') or False
+        self.category_id: Optional[int] = _get_as_snowflake(data, 'parent_id')
+        self.slowmode_delay: int = data.get('rate_limit_per_user') or 0
+        self.last_message_id: Optional[int] = _get_as_snowflake(data, 'last_message_id')
+        self._last_pin: Optional[datetime] = parse_time(data.get('last_pin_timestamp'))
+        self._flags: int = data.get('flags', 0)
 
     def __str__(self) -> str:
         return self.name
@@ -611,6 +656,28 @@ def guild(self) -> Optional[Guild]:
         """Optional[:class:`~discord.Guild`]: The channel's guild, from cache, if found."""
         return self._state._get_guild(self.guild_id)
 
+    @property
+    def flags(self) -> ChannelFlags:
+        """:class:`~discord.ChannelFlags`: The flags associated with this channel object.
+
+        .. versionadded:: 2.6
+        """
+        return ChannelFlags._from_value(self._flags)
+
+    def is_nsfw(self) -> bool:
+        """:class:`bool`: Checks if the channel is NSFW.
+
+        .. versionadded:: 2.6
+        """
+        return self.nsfw
+
+    def is_news(self) -> bool:
+        """:class:`bool`: Checks if the channel is a news channel.
+
+        .. versionadded:: 2.6
+        """
+        return self.type == ChannelType.news
+
     def resolve(self) -> Optional[GuildChannel]:
         """Resolves the application command channel to the appropriate channel
         from cache if found.
@@ -1063,6 +1130,9 @@ def __init__(self, *, data: ApplicationCommandPermissions, guild: Guild, state:
 
         self.target: Union[Object, User, Member, Role, AllChannels, GuildChannel] = _object
 
+    def __repr__(self) -> str:
+        return f'<AppCommandPermissions id={self.id} type={self.type!r} guild={self.guild!r} permission={self.permission}>'
+
     def to_dict(self) -> ApplicationCommandPermissions:
         return {
             'id': self.target.id,
@@ -1106,6 +1176,9 @@ def __init__(self, *, data: GuildApplicationCommandPermissions, state: Connectio
             AppCommandPermissions(data=value, guild=guild, state=self._state) for value in data['permissions']
         ]
 
+    def __repr__(self) -> str:
+        return f'<GuildAppCommandPermissions id={self.id!r} guild_id={self.guild_id!r} permissions={self.permissions!r}>'
+
     def to_dict(self) -> Dict[str, Any]:
         return {'permissions': [p.to_dict() for p in self.permissions]}
 

discord/app_commands/transformers.py

@@ -52,7 +52,7 @@
 from ..abc import GuildChannel
 from ..threads import Thread
 from ..enums import Enum as InternalEnum, AppCommandOptionType, ChannelType, Locale
-from ..utils import MISSING, maybe_coroutine
+from ..utils import MISSING, maybe_coroutine, _human_join
 from ..user import User
 from ..role import Role
 from ..member import Member
@@ -631,7 +631,7 @@ def __init__(self, *channel_types: Type[Any]) -> None:
             display_name = channel_types[0].__name__
             types = CHANNEL_TO_TYPES[channel_types[0]]
         else:
-            display_name = '{}, and {}'.format(', '.join(t.__name__ for t in channel_types[:-1]), channel_types[-1].__name__)
+            display_name = _human_join([t.__name__ for t in channel_types])
             types = []
 
             for t in channel_types:
@@ -689,6 +689,7 @@ async def transform(self, interaction: Interaction[ClientT], value: Any, /):
         ChannelType.news,
         ChannelType.category,
         ChannelType.forum,
+        ChannelType.media,
     ],
     GuildChannel: [
         ChannelType.stage_voice,
@@ -697,14 +698,15 @@ async def transform(self, interaction: Interaction[ClientT], value: Any, /):
         ChannelType.news,
         ChannelType.category,
         ChannelType.forum,
+        ChannelType.media,
     ],
     AppCommandThread: [ChannelType.news_thread, ChannelType.private_thread, ChannelType.public_thread],
     Thread: [ChannelType.news_thread, ChannelType.private_thread, ChannelType.public_thread],
     StageChannel: [ChannelType.stage_voice],
     VoiceChannel: [ChannelType.voice],
     TextChannel: [ChannelType.text, ChannelType.news],
     CategoryChannel: [ChannelType.category],
-    ForumChannel: [ChannelType.forum],
+    ForumChannel: [ChannelType.forum, ChannelType.media],
 }
 
 BUILT_IN_TRANSFORMERS: Dict[Any, Transformer] = {

discord/audit_logs.py

@@ -69,7 +69,7 @@
         DefaultReaction as DefaultReactionPayload,
     )
     from .types.invite import Invite as InvitePayload
-    from .types.role import Role as RolePayload
+    from .types.role import Role as RolePayload, RoleColours
     from .types.snowflake import Snowflake
     from .types.command import ApplicationCommandPermissions
     from .types.automod import AutoModerationAction
@@ -145,8 +145,8 @@ def _transform_applied_forum_tags(entry: AuditLogEntry, data: List[Snowflake]) -
     return [Object(id=tag_id, type=ForumTag) for tag_id in data]
 
 
-def _transform_overloaded_flags(entry: AuditLogEntry, data: int) -> Union[int, flags.ChannelFlags]:
-    # The `flags` key is definitely overloaded. Right now it's for channels and threads but
+def _transform_overloaded_flags(entry: AuditLogEntry, data: int) -> Union[int, flags.ChannelFlags, flags.InviteFlags]:
+    # The `flags` key is definitely overloaded. Right now it's for channels, threads and invites but
     # I am aware of `member.flags` and `user.flags` existing. However, this does not impact audit logs
     # at the moment but better safe than sorry.
     channel_audit_log_types = (
@@ -157,9 +157,16 @@ def _transform_overloaded_flags(entry: AuditLogEntry, data: int) -> Union[int, f
         enums.AuditLogAction.thread_update,
         enums.AuditLogAction.thread_delete,
     )
+    invite_audit_log_types = (
+        enums.AuditLogAction.invite_create,
+        enums.AuditLogAction.invite_update,
+        enums.AuditLogAction.invite_delete,
+    )
 
     if entry.action in channel_audit_log_types:
         return flags.ChannelFlags._from_value(data)
+    elif entry.action in invite_audit_log_types:
+        return flags.InviteFlags._from_value(data)
     return data
 
 
@@ -400,6 +407,12 @@ def __init__(self, entry: AuditLogEntry, data: List[AuditLogChangePayload]):
                     self._handle_trigger_attr_update(self.after, self.before, entry, trigger_attr, elem['new_value'])  # type: ignore
                 continue
 
+            # special case for colors to set secondary and tertiary colos/colour attributes
+            if attr == 'colors':
+                self._handle_colours(self.before, elem['old_value'])  # type: ignore  # should be a RoleColours dict
+                self._handle_colours(self.after, elem['new_value'])  # type: ignore  # should be a RoleColours dict
+                continue
+
             try:
                 key, transformer = self.TRANSFORMERS[attr]
             except (ValueError, KeyError):
@@ -532,6 +545,16 @@ def _handle_trigger_attr_update(
         except (AttributeError, TypeError):
             pass
 
+    def _handle_colours(self, diff: AuditLogDiff, colours: RoleColours):
+        # handle colours to multiple colour attributes
+        diff.color = diff.colour = Colour(colours['primary_color'])
+
+        secondary_colour = colours['secondary_color']
+        tertiary_colour = colours['tertiary_color']
+
+        diff.secondary_color = diff.secondary_colour = Colour(secondary_colour) if secondary_colour is not None else None
+        diff.tertiary_color = diff.tertiary_colour = Colour(tertiary_colour) if tertiary_colour is not None else None
+
     def _create_trigger(self, diff: AuditLogDiff, entry: AuditLogEntry) -> AutoModTrigger:
         # check if trigger has already been created
         if not hasattr(diff, 'trigger'):