From 8699d2139ae2dd36f68976175b863d219c5bcf21 Mon Sep 17 00:00:00 2001 From: Rapptz Date: Tue, 3 May 2022 10:49:52 -0400 Subject: [PATCH] Improve generic duck type programming with PartialMessageable This adds jump_url, permissions_for, and created_at. Luckily, most cases of this type being constructed already have the guild_id at creation time. --- discord/app_commands/namespace.py | 6 +++-- discord/channel.py | 39 ++++++++++++++++++++++++++++++- discord/client.py | 11 +++++++-- discord/ext/commands/context.py | 4 +++- discord/interactions.py | 2 +- discord/state.py | 2 +- discord/webhook/async_.py | 4 ++-- discord/webhook/sync.py | 2 +- 8 files changed, 59 insertions(+), 11 deletions(-) diff --git a/discord/app_commands/namespace.py b/discord/app_commands/namespace.py index 489833f9c..81d8f35ad 100644 --- a/discord/app_commands/namespace.py +++ b/discord/app_commands/namespace.py @@ -213,9 +213,11 @@ class Namespace: for (message_id, message_data) in resolved.get('messages', {}).items(): channel_id = int(message_data['channel_id']) if guild is None: - channel = PartialMessageable(state=state, id=channel_id) + channel = PartialMessageable(state=state, guild_id=guild_id, id=channel_id) else: - channel = guild.get_channel_or_thread(channel_id) or PartialMessageable(state=state, id=channel_id) + channel = guild.get_channel_or_thread(channel_id) or PartialMessageable( + state=state, guild_id=guild_id, id=channel_id + ) # Type checker doesn't understand this due to failure to narrow message = Message(state=state, channel=channel, data=message_data) # type: ignore diff --git a/discord/channel.py b/discord/channel.py index b6a828435..f2dbdffab 100644 --- a/discord/channel.py +++ b/discord/channel.py @@ -2611,13 +2611,16 @@ class PartialMessageable(discord.abc.Messageable, Hashable): ----------- id: :class:`int` The channel ID associated with this partial messageable. + guild_id: Optional[:class:`int`] + The guild ID associated with this partial messageable. type: Optional[:class:`ChannelType`] The channel type associated with this partial messageable, if given. """ - def __init__(self, state: ConnectionState, id: int, type: Optional[ChannelType] = None): + def __init__(self, state: ConnectionState, id: int, guild_id: Optional[int] = None, type: Optional[ChannelType] = None): self._state: ConnectionState = state self.id: int = id + self.guild_id: Optional[int] = guild_id self.type: Optional[ChannelType] = type def __repr__(self) -> str: @@ -2626,6 +2629,40 @@ class PartialMessageable(discord.abc.Messageable, Hashable): async def _get_channel(self) -> PartialMessageable: return self + @property + def jump_url(self) -> str: + """:class:`str`: Returns a URL that allows the client to jump to the channel.""" + if self.guild_id is None: + return f'https://discord.com/channels/@me/{self.id}' + return f'https://discord.com/channels/{self.guild_id}/{self.id}' + + @property + def created_at(self) -> datetime.datetime: + """:class:`datetime.datetime`: Returns the direct message channel's creation time in UTC.""" + return utils.snowflake_time(self.id) + + def permissions_for(self, obj: Any = None, /) -> Permissions: + """Handles permission resolution for a :class:`User`. + + This function is there for compatibility with other channel types. + + Since partial messageables cannot reasonably have the concept of + permissions, this will always return :meth:`Permissions.none`. + + Parameters + ----------- + obj: :class:`User` + The user to check permissions for. This parameter is ignored + but kept for compatibility with other ``permissions_for`` methods. + + Returns + -------- + :class:`Permissions` + The resolved permissions. + """ + + return Permissions.none() + def get_partial_message(self, message_id: int, /) -> PartialMessage: """Creates a :class:`PartialMessage` from the message ID. diff --git a/discord/client.py b/discord/client.py index 09b0af256..c579ded55 100644 --- a/discord/client.py +++ b/discord/client.py @@ -807,7 +807,9 @@ class Client: """ return self._connection.get_channel(id) # type: ignore # The cache contains all channel types - def get_partial_messageable(self, id: int, *, type: Optional[ChannelType] = None) -> PartialMessageable: + def get_partial_messageable( + self, id: int, *, guild_id: Optional[int] = None, type: Optional[ChannelType] = None + ) -> PartialMessageable: """Returns a partial messageable with the given channel ID. This is useful if you have a channel_id but don't want to do an API call @@ -819,6 +821,11 @@ class Client: ----------- id: :class:`int` The channel ID to create a partial messageable for. + guild_id: Optional[:class:`int`] + The optional guild ID to create a partial messageable for. + + This is not required to actually send messages, but it does allow the + :meth:`PartialMessageable.jump_url` property to form a well formed URL. type: Optional[:class:`.ChannelType`] The underlying channel type for the partial messageable. @@ -827,7 +834,7 @@ class Client: :class:`.PartialMessageable` The partial messageable """ - return PartialMessageable(state=self._connection, id=id, type=type) + return PartialMessageable(state=self._connection, id=id, guild_id=guild_id, type=type) def get_stage_instance(self, id: int, /) -> Optional[StageInstance]: """Returns a stage instance with the given stage channel ID. diff --git a/discord/ext/commands/context.py b/discord/ext/commands/context.py index d5ab7ebc9..2eff4b94b 100644 --- a/discord/ext/commands/context.py +++ b/discord/ext/commands/context.py @@ -244,7 +244,9 @@ class Context(discord.abc.Messageable, Generic[BotT]): if interaction.channel_id is None: raise RuntimeError('interaction channel ID is null, this is probably a Discord bug') - channel = interaction.channel or PartialMessageable(state=interaction._state, id=interaction.channel_id) + channel = interaction.channel or PartialMessageable( + state=interaction._state, guild_id=interaction.guild_id, id=interaction.channel_id + ) message = Message(state=interaction._state, channel=channel, data=synthetic_payload) # type: ignore message.author = interaction.user message.attachments = [a for _, a in interaction.namespace if isinstance(a, Attachment)] diff --git a/discord/interactions.py b/discord/interactions.py index 317ca2f0c..dec4cb424 100644 --- a/discord/interactions.py +++ b/discord/interactions.py @@ -223,7 +223,7 @@ class Interaction: if channel is None: if self.channel_id is not None: type = ChannelType.text if self.guild_id is not None else ChannelType.private - return PartialMessageable(state=self._state, id=self.channel_id, type=type) + return PartialMessageable(state=self._state, guild_id=self.guild_id, id=self.channel_id, type=type) return None return channel diff --git a/discord/state.py b/discord/state.py index d9c1a3d3b..36cf47ae6 100644 --- a/discord/state.py +++ b/discord/state.py @@ -480,7 +480,7 @@ class ConnectionState: else: channel = guild and guild._resolve_channel(channel_id) - return channel or PartialMessageable(state=self, id=channel_id), guild + return channel or PartialMessageable(state=self, guild_id=guild_id, id=channel_id), guild async def chunker( self, guild_id: int, query: str = '', limit: int = 0, presences: bool = False, *, nonce: Optional[str] = None diff --git a/discord/webhook/async_.py b/discord/webhook/async_.py index 52884f92e..223ce88ad 100644 --- a/discord/webhook/async_.py +++ b/discord/webhook/async_.py @@ -1345,14 +1345,14 @@ class Webhook(BaseWebhook): state = _WebhookState(self, parent=self._state, thread=thread) # state may be artificial (unlikely at this point...) if thread is MISSING: - channel = self.channel or PartialMessageable(state=self._state, id=int(data['channel_id'])) # type: ignore + channel = self.channel or PartialMessageable(state=self._state, guild_id=self.guild_id, id=int(data['channel_id'])) # type: ignore else: channel = self.channel if isinstance(channel, TextChannel): channel = channel.get_thread(thread.id) if channel is None: - channel = PartialMessageable(state=self._state, id=int(data['channel_id'])) # type: ignore + channel = PartialMessageable(state=self._state, guild_id=self.guild_id, id=int(data['channel_id'])) # type: ignore # state is artificial return WebhookMessage(data=data, state=state, channel=channel) # type: ignore diff --git a/discord/webhook/sync.py b/discord/webhook/sync.py index b03fdd4a9..cf329c93e 100644 --- a/discord/webhook/sync.py +++ b/discord/webhook/sync.py @@ -842,7 +842,7 @@ class SyncWebhook(BaseWebhook): def _create_message(self, data: MessagePayload, *, thread: Snowflake = MISSING) -> SyncWebhookMessage: state = _WebhookState(self, parent=self._state, thread=thread) # state may be artificial (unlikely at this point...) - channel = self.channel or PartialMessageable(state=self._state, id=int(data['channel_id'])) # type: ignore + channel = self.channel or PartialMessageable(state=self._state, guild_id=self.guild_id, id=int(data['channel_id'])) # type: ignore # state is artificial return SyncWebhookMessage(data=data, state=state, channel=channel) # type: ignore