mirror of
https://github.com/Cog-Creators/Red-DiscordBot.git
synced 2025-11-06 11:18:54 -05:00
febca8ccbb
* Temporarily set d.py to use latest git revision
* Remove `bot` param to Client.start
* Switch to aware datetimes
A lot of this is removing `.replace(...)` which while not technically
needed, simplifies the code base. There's only a few changes that are
actually necessary here.
* Update to work with new Asset design
* [threads] Update core ModLog API to support threads
- Added proper support for passing `Thread` to `channel`
when creating/editing case
- Added `parent_channel_id` attribute to Modlog API's Case
- Added `parent_channel` property that tries to get parent channel
- Updated case's content to show both thread and parent information
* [threads] Disallow usage of threads in some of the commands
- announceset channel
- filter channel clear
- filter channel add
- filter channel remove
- GlobalUniqueObjectFinder converter
- permissions addglobalrule
- permissions removeglobalrule
- permissions removeserverrule
- Permissions cog does not perform any validation for IDs
when setting through YAML so that has not been touched
- streamalert twitch/youtube/picarto
- embedset channel
- set ownernotifications adddestination
* [threads] Handle threads in Red's permissions system (Requires)
- Made permissions system apply rules of (only) parent in threads
* [threads] Update embed_requested to support threads
- Threads don't have their own embed settings and inherit from parent
* [threads] Update Red.message_eligible_as_command to support threads
* [threads] Properly handle invocation of [p](un)mutechannel in threads
Usage of a (un)mutechannel will mute/unmute user in the parent channel
if it's invoked in a thread.
* [threads] Update Filter cog to properly handle threads
- `[p]filter channel list` in a threads sends list for parent channel
- Checking for filter hits for a message in a thread checks its parent
channel's word list. There's no separate word list for threads.
* [threads] Support threads in Audio cog
- Handle threads being notify channels
- Update type hint for `is_query_allowed()`
* [threads] Update type hints and documentation to reflect thread support
- Documented that `{channel}` in CCs might be a thread
- Allowed (documented) usage of threads with `Config.channel()`
- Separate thread scope is still in the picture though
if it were to be done, it's going to be in separate in PR
- GuildContext.channel might be Thread
* Use less costy channel check in customcom's on_message_without_command
This isn't needed for d.py 2.0 but whatever...
* Update for in-place edits
* Embed's bool changed behavior, I'm hoping it doesn't affect us
* Address User.permissions_in() removal
* Swap VerificationLevel.extreme with VerificationLevel.highest
* Change to keyword-only parameters
* Change of `Guild.vanity_invite()` return type
* avatar -> display_avatar
* Fix metaclass shenanigans with Converter
* Update Red.add_cog() to be inline with `dpy_commands.Bot.add_cog()`
This means adding `override` keyword-only parameter and causing
small breakage by swapping RuntimeError with discord.ClientException.
* Address all DEP-WARNs
* Remove Context.clean_prefix and use upstream implementation instead
* Remove commands.Literal and use upstream implementation instead
Honestly, this was a rather bad implementation anyway...
Breaking but actually not really - it was provisional.
* Update Command.callback's setter
Support for functools.partial is now built into d.py
* Add new perms in HUMANIZED_PERM mapping (some from d.py 1.7 it seems)
BTW, that should really be in core instead of what we have now...
* Remove the part of do_conversion that has not worked for a long while
* Stop wrapping BadArgument in ConversionFailure
This is breaking but it's best to resolve it like this.
The functionality of ConversionFailure can be replicated with
Context.current_parameter and Context.current_argument.
* Add custom errors for int and float converters
* Remove Command.__call__ as it's now implemented in d.py
* Get rid of _dpy_reimplements
These were reimplemented for the purpose of typing
so it is no longer needed now that d.py is type hinted.
* Add return to Red.remove_cog
* Ensure we don't delete messages that differ only by used sticker
* discord.InvalidArgument->ValueError
* Move from raw <t:...> syntax to discord.utils.format_dt()
* Address AsyncIter removal
* Swap to pos-only for params that are pos-only in upstream
* Update for changes to Command.params
* [threads] Support threads in ignore checks and allow ignoring them
- Updated `[p](un)ignore channel` to accept threads
- Updated `[p]ignore list` to list ignored threads
- Updated logic in `Red.ignored_channel_or_guild()`
Ignores for guild channels now work as follows (only changes for threads):
- if channel is not a thread:
- check if user has manage channels perm in channel
and allow command usage if so
- check if channel is ignored and disallow command usage if so
- allow command usage if none of the conditions above happened
- if channel is a thread:
- check if user has manage channels perm in parent channel
and allow command usage if so
- check if parent channel is ignored and disallow command usage
if so
- check if user has manage thread perm in parent channel
and allow command usage if so
- check if thread is ignored and disallow command usage if so
- allow command usage if none of the conditions above happened
* [partial] Raise TypeError when channel is of PartialMessageable type
- Red.embed_requested
- Red.ignored_channel_or_guild
* [partial] Discard command messages when channel is PartialMessageable
* [threads] Add utilities for checking appropriate perms in both channels & threads
* [threads] Update code to use can_react_in() and @bot_can_react()
* [threads] Update code to use can_send_messages_in
* [threads] Add send_messages_in_threads perm to mute role and overrides
* [threads] Update code to use (bot/user)_can_manage_channel
* [threads] Update [p]diagnoseissues to work with threads
* Type hint fix
* [threads] Patch vendored discord.ext.menus to check proper perms in threads
I guess we've reached time when we have to patch the lib we vendor...
* Make docs generation work with non-final d.py releases
* Update discord.utils.oauth_url() usage
* Swap usage of discord.Embed.Empty/discord.embeds.EmptyEmbed to None
* Update usage of Guild.member_count to work with `None`
* Switch from Guild.vanity_invite() to Guild.vanity_url
* Update startup process to work with d.py's new asynchronous startup
* Use setup_hook() for pre-connect actions
* Update core's add_cog, remove_cog, and load_extension methods
* Update all setup functions to async and add awaits to bot.add_cog calls
* Modernize cogs by using async cog_load and cog_unload
* Address StoreChannel removal
* [partial] Disallow passing PartialMessageable to Case.channel
* [partial] Update cogs and utils to work better with PartialMessageable
- Ignore messages with PartialMessageable channel in CustomCommands cog
- In Filter cog, don't pass channel to modlog.create_case()
if it's PartialMessageable
- In Trivia cog, only compare channel IDs
- Make `.utils.menus.menu()` work for messages
with PartialMessageable channel
- Make checks in `.utils.tunnel.Tunnel.communicate()` more rigid
* Add few missing DEP-WARNs
1021 lines
33 KiB
Python
1021 lines
33 KiB
Python
from __future__ import annotations
|
|
|
|
import re
|
|
from typing import Callable, ClassVar, List, Optional, Pattern, Sequence, Tuple, Union, cast
|
|
|
|
import discord
|
|
|
|
from redbot.core import commands
|
|
|
|
_ID_RE = re.compile(r"([0-9]{15,20})$")
|
|
_USER_MENTION_RE = re.compile(r"<@!?([0-9]{15,20})>$")
|
|
_CHAN_MENTION_RE = re.compile(r"<#([0-9]{15,20})>$")
|
|
_ROLE_MENTION_RE = re.compile(r"<@&([0-9]{15,20})>$")
|
|
|
|
|
|
class MessagePredicate(Callable[[discord.Message], bool]):
|
|
"""A simple collection of predicates for message events.
|
|
|
|
These predicates intend to help simplify checks in message events
|
|
and reduce boilerplate code.
|
|
|
|
This class should be created through the provided classmethods.
|
|
Instances of this class are callable message predicates, i.e. they
|
|
return ``True`` if a message matches the criteria.
|
|
|
|
All predicates are combined with :meth:`MessagePredicate.same_context`.
|
|
|
|
Examples
|
|
--------
|
|
Waiting for a response in the same channel and from the same
|
|
author::
|
|
|
|
await bot.wait_for("message", check=MessagePredicate.same_context(ctx))
|
|
|
|
Waiting for a response to a yes or no question::
|
|
|
|
pred = MessagePredicate.yes_or_no(ctx)
|
|
await bot.wait_for("message", check=pred)
|
|
if pred.result is True:
|
|
# User responded "yes"
|
|
...
|
|
|
|
Getting a member object from a user's response::
|
|
|
|
pred = MessagePredicate.valid_member(ctx)
|
|
await bot.wait_for("message", check=pred)
|
|
member = pred.result
|
|
|
|
Attributes
|
|
----------
|
|
result : Any
|
|
The object which the message content matched with. This is
|
|
dependent on the predicate used - see each predicate's
|
|
documentation for details, not every method will assign this
|
|
attribute. Defaults to ``None``.
|
|
|
|
"""
|
|
|
|
def __init__(self, predicate: Callable[["MessagePredicate", discord.Message], bool]) -> None:
|
|
self._pred: Callable[["MessagePredicate", discord.Message], bool] = predicate
|
|
self.result = None
|
|
|
|
def __call__(self, message: discord.Message) -> bool:
|
|
return self._pred(self, message)
|
|
|
|
@classmethod
|
|
def same_context(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the message fits the described context.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
The current invocation context.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
The channel we expect a message in. If unspecified,
|
|
defaults to ``ctx.channel``. If ``ctx`` is unspecified
|
|
too, the message's channel will be ignored.
|
|
user : Optional[discord.abc.User]
|
|
The user we expect a message from. If unspecified,
|
|
defaults to ``ctx.author``. If ``ctx`` is unspecified
|
|
too, the message's author will be ignored.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
if ctx is not None:
|
|
channel = channel or ctx.channel
|
|
user = user or ctx.author
|
|
|
|
return cls(
|
|
lambda self, m: (user is None or user.id == m.author.id)
|
|
and (channel is None or channel.id == m.channel.id)
|
|
)
|
|
|
|
@classmethod
|
|
def cancelled(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the message is ``[p]cancel``.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
return cls(
|
|
lambda self, m: (same_context(m) and m.content.lower() == f"{ctx.prefix}cancel")
|
|
)
|
|
|
|
@classmethod
|
|
def yes_or_no(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the message is "yes"/"y" or "no"/"n".
|
|
|
|
This will assign ``True`` for *yes*, or ``False`` for *no* to
|
|
the `result` attribute.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
content = m.content.lower()
|
|
if content in ("yes", "y"):
|
|
self.result = True
|
|
elif content in ("no", "n"):
|
|
self.result = False
|
|
else:
|
|
return False
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def valid_int(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is an integer.
|
|
|
|
Assigns the response to `result` as an `int`.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
try:
|
|
self.result = int(m.content)
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def valid_float(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is a float.
|
|
|
|
Assigns the response to `result` as a `float`.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
try:
|
|
self.result = float(m.content)
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def positive(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is a positive number.
|
|
|
|
Assigns the response to `result` as a `float`.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
try:
|
|
number = float(m.content)
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
if number > 0:
|
|
self.result = number
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def valid_role(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response refers to a role in the current guild.
|
|
|
|
Assigns the matching `discord.Role` object to `result`.
|
|
|
|
This predicate cannot be used in DM.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
guild = cls._get_guild(ctx, channel, cast(discord.Member, user))
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
|
|
role = self._find_role(guild, m.content)
|
|
if role is None:
|
|
return False
|
|
|
|
self.result = role
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def valid_member(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response refers to a member in the current guild.
|
|
|
|
Assigns the matching `discord.Member` object to `result`.
|
|
|
|
This predicate cannot be used in DM.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
guild = cls._get_guild(ctx, channel, cast(discord.Member, user))
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
|
|
match = _ID_RE.match(m.content) or _USER_MENTION_RE.match(m.content)
|
|
if match:
|
|
result = guild.get_member(int(match.group(1)))
|
|
else:
|
|
result = guild.get_member_named(m.content)
|
|
|
|
if result is None:
|
|
return False
|
|
self.result = result
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def valid_text_channel(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response refers to a text channel in the current guild.
|
|
|
|
Assigns the matching `discord.TextChannel` object to `result`.
|
|
|
|
This predicate cannot be used in DM.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
guild = cls._get_guild(ctx, channel, cast(discord.Member, user))
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
|
|
match = _ID_RE.match(m.content) or _CHAN_MENTION_RE.match(m.content)
|
|
if match:
|
|
result = guild.get_channel(int(match.group(1)))
|
|
else:
|
|
result = discord.utils.get(guild.text_channels, name=m.content)
|
|
|
|
if not isinstance(result, discord.TextChannel):
|
|
return False
|
|
self.result = result
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def has_role(
|
|
cls,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response refers to a role which the author has.
|
|
|
|
Assigns the matching `discord.Role` object to `result`.
|
|
|
|
One of ``user`` or ``ctx`` must be supplied. This predicate
|
|
cannot be used in DM.
|
|
|
|
Parameters
|
|
----------
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
guild = cls._get_guild(ctx, channel, cast(discord.Member, user))
|
|
if user is None:
|
|
if ctx is None:
|
|
raise TypeError(
|
|
"One of `user` or `ctx` must be supplied to `MessagePredicate.has_role`."
|
|
)
|
|
user = ctx.author
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
|
|
role = self._find_role(guild, m.content)
|
|
if role is None or role not in user.roles:
|
|
return False
|
|
|
|
self.result = role
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def equal_to(
|
|
cls,
|
|
value: str,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is equal to the specified value.
|
|
|
|
Parameters
|
|
----------
|
|
value : str
|
|
The value to compare the response with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
return cls(lambda self, m: same_context(m) and m.content == value)
|
|
|
|
@classmethod
|
|
def lower_equal_to(
|
|
cls,
|
|
value: str,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response *as lowercase* is equal to the specified value.
|
|
|
|
Parameters
|
|
----------
|
|
value : str
|
|
The value to compare the response with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
return cls(lambda self, m: same_context(m) and m.content.lower() == value)
|
|
|
|
@classmethod
|
|
def less(
|
|
cls,
|
|
value: Union[int, float],
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is less than the specified value.
|
|
|
|
Parameters
|
|
----------
|
|
value : Union[int, float]
|
|
The value to compare the response with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
valid_int = cls.valid_int(ctx, channel, user)
|
|
valid_float = cls.valid_float(ctx, channel, user)
|
|
return cls(lambda self, m: (valid_int(m) or valid_float(m)) and float(m.content) < value)
|
|
|
|
@classmethod
|
|
def greater(
|
|
cls,
|
|
value: Union[int, float],
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is greater than the specified value.
|
|
|
|
Parameters
|
|
----------
|
|
value : Union[int, float]
|
|
The value to compare the response with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
valid_int = cls.valid_int(ctx, channel, user)
|
|
valid_float = cls.valid_float(ctx, channel, user)
|
|
return cls(lambda self, m: (valid_int(m) or valid_float(m)) and float(m.content) > value)
|
|
|
|
@classmethod
|
|
def length_less(
|
|
cls,
|
|
length: int,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response's length is less than the specified length.
|
|
|
|
Parameters
|
|
----------
|
|
length : int
|
|
The value to compare the response's length with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
return cls(lambda self, m: same_context(m) and len(m.content) <= length)
|
|
|
|
@classmethod
|
|
def length_greater(
|
|
cls,
|
|
length: int,
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response's length is greater than the specified length.
|
|
|
|
Parameters
|
|
----------
|
|
length : int
|
|
The value to compare the response's length with.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
return cls(lambda self, m: same_context(m) and len(m.content) >= length)
|
|
|
|
@classmethod
|
|
def contained_in(
|
|
cls,
|
|
collection: Sequence[str],
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response is contained in the specified collection.
|
|
|
|
The index of the response in the ``collection`` sequence is
|
|
assigned to the `result` attribute.
|
|
|
|
Parameters
|
|
----------
|
|
collection : Sequence[str]
|
|
The collection containing valid responses.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
try:
|
|
self.result = collection.index(m.content)
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def lower_contained_in(
|
|
cls,
|
|
collection: Sequence[str],
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Same as :meth:`contained_in`, but the response is set to lowercase before matching.
|
|
|
|
Parameters
|
|
----------
|
|
collection : Sequence[str]
|
|
The collection containing valid lowercase responses.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
try:
|
|
self.result = collection.index(m.content.lower())
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def regex(
|
|
cls,
|
|
pattern: Union[Pattern[str], str],
|
|
ctx: Optional[commands.Context] = None,
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread, discord.DMChannel]] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "MessagePredicate":
|
|
"""Match if the response matches the specified regex pattern.
|
|
|
|
This predicate will use `re.search` to find a match. The
|
|
resulting `match object <match-objects>` will be assigned
|
|
to `result`.
|
|
|
|
Parameters
|
|
----------
|
|
pattern : Union[`pattern object <re-objects>`, str]
|
|
The pattern to search for in the response.
|
|
ctx : Optional[Context]
|
|
Same as ``ctx`` in :meth:`same_context`.
|
|
channel : Optional[Union[`discord.TextChannel`, `discord.Thread`, `discord.DMChannel`]]
|
|
Same as ``channel`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
MessagePredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(ctx, channel, user)
|
|
|
|
def predicate(self: MessagePredicate, m: discord.Message) -> bool:
|
|
if not same_context(m):
|
|
return False
|
|
|
|
if isinstance(pattern, str):
|
|
pattern_obj = re.compile(pattern)
|
|
else:
|
|
pattern_obj = pattern
|
|
|
|
match = pattern_obj.search(m.content)
|
|
if match:
|
|
self.result = match
|
|
return True
|
|
return False
|
|
|
|
return cls(predicate)
|
|
|
|
@staticmethod
|
|
def _find_role(guild: discord.Guild, argument: str) -> Optional[discord.Role]:
|
|
match = _ID_RE.match(argument) or _ROLE_MENTION_RE.match(argument)
|
|
if match:
|
|
result = guild.get_role(int(match.group(1)))
|
|
else:
|
|
result = discord.utils.get(guild.roles, name=argument)
|
|
return result
|
|
|
|
@staticmethod
|
|
def _get_guild(
|
|
ctx: Optional[commands.Context],
|
|
channel: Optional[Union[discord.TextChannel, discord.Thread]],
|
|
user: Optional[discord.Member],
|
|
) -> discord.Guild:
|
|
if ctx is not None:
|
|
return ctx.guild
|
|
elif channel is not None:
|
|
return channel.guild
|
|
elif user is not None:
|
|
return user.guild
|
|
|
|
|
|
class ReactionPredicate(Callable[[discord.Reaction, discord.abc.User], bool]):
|
|
"""A collection of predicates for reaction events.
|
|
|
|
All checks are combined with :meth:`ReactionPredicate.same_context`.
|
|
|
|
Examples
|
|
--------
|
|
Confirming a yes/no question with a tick/cross reaction::
|
|
|
|
from redbot.core.utils.predicates import ReactionPredicate
|
|
from redbot.core.utils.menus import start_adding_reactions
|
|
|
|
msg = await ctx.send("Yes or no?")
|
|
start_adding_reactions(msg, ReactionPredicate.YES_OR_NO_EMOJIS)
|
|
|
|
pred = ReactionPredicate.yes_or_no(msg, ctx.author)
|
|
await ctx.bot.wait_for("reaction_add", check=pred)
|
|
if pred.result is True:
|
|
# User responded with tick
|
|
...
|
|
else:
|
|
# User responded with cross
|
|
...
|
|
|
|
Waiting for the first reaction from any user with one of the first
|
|
5 letters of the alphabet::
|
|
|
|
from redbot.core.utils.predicates import ReactionPredicate
|
|
from redbot.core.utils.menus import start_adding_reactions
|
|
|
|
msg = await ctx.send("React to me!")
|
|
emojis = ReactionPredicate.ALPHABET_EMOJIS[:5]
|
|
start_adding_reactions(msg, emojis)
|
|
|
|
pred = ReactionPredicate.with_emojis(emojis, msg)
|
|
await ctx.bot.wait_for("reaction_add", check=pred)
|
|
# pred.result is now the index of the letter in `emojis`
|
|
|
|
Attributes
|
|
----------
|
|
result : Any
|
|
The object which the reaction matched with. This is
|
|
dependent on the predicate used - see each predicate's
|
|
documentation for details, not every method will assign this
|
|
attribute. Defaults to ``None``.
|
|
|
|
"""
|
|
|
|
YES_OR_NO_EMOJIS: ClassVar[Tuple[str, str]] = (
|
|
"\N{WHITE HEAVY CHECK MARK}",
|
|
"\N{NEGATIVE SQUARED CROSS MARK}",
|
|
)
|
|
"""Tuple[str, str] : A tuple containing the tick emoji and cross emoji, in that order."""
|
|
|
|
ALPHABET_EMOJIS: ClassVar[List[str]] = [
|
|
chr(code)
|
|
for code in range(
|
|
ord("\N{REGIONAL INDICATOR SYMBOL LETTER A}"),
|
|
ord("\N{REGIONAL INDICATOR SYMBOL LETTER Z}") + 1,
|
|
)
|
|
]
|
|
"""List[str] : A list of all 26 alphabetical letter emojis."""
|
|
|
|
NUMBER_EMOJIS: ClassVar[List[str]] = [
|
|
chr(code) + "\N{COMBINING ENCLOSING KEYCAP}" for code in range(ord("0"), ord("9") + 1)
|
|
]
|
|
"""List[str] : A list of all single-digit number emojis, 0 through 9."""
|
|
|
|
def __init__(
|
|
self, predicate: Callable[["ReactionPredicate", discord.Reaction, discord.abc.User], bool]
|
|
) -> None:
|
|
self._pred: Callable[
|
|
["ReactionPredicate", discord.Reaction, discord.abc.User], bool
|
|
] = predicate
|
|
self.result = None
|
|
|
|
def __call__(self, reaction: discord.Reaction, user: discord.abc.User) -> bool:
|
|
return self._pred(self, reaction, user)
|
|
|
|
# noinspection PyUnusedLocal
|
|
@classmethod
|
|
def same_context(
|
|
cls, message: Optional[discord.Message] = None, user: Optional[discord.abc.User] = None
|
|
) -> "ReactionPredicate":
|
|
"""Match if a reaction fits the described context.
|
|
|
|
This will ignore reactions added by the bot user, regardless
|
|
of whether or not ``user`` is supplied.
|
|
|
|
Parameters
|
|
----------
|
|
message : Optional[discord.Message]
|
|
The message which we expect a reaction to. If unspecified,
|
|
the reaction's message will be ignored.
|
|
user : Optional[discord.abc.User]
|
|
The user we expect to react. If unspecified, the user who
|
|
added the reaction will be ignored.
|
|
|
|
Returns
|
|
-------
|
|
ReactionPredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
# noinspection PyProtectedMember
|
|
# DEP-WARN
|
|
me_id = message._state.self_id
|
|
return cls(
|
|
lambda self, r, u: u.id != me_id
|
|
and (message is None or r.message.id == message.id)
|
|
and (user is None or u.id == user.id)
|
|
)
|
|
|
|
@classmethod
|
|
def with_emojis(
|
|
cls,
|
|
emojis: Sequence[Union[str, discord.Emoji, discord.PartialEmoji]],
|
|
message: Optional[discord.Message] = None,
|
|
user: Optional[discord.abc.User] = None,
|
|
) -> "ReactionPredicate":
|
|
"""Match if the reaction is one of the specified emojis.
|
|
|
|
Parameters
|
|
----------
|
|
emojis : Sequence[Union[str, discord.Emoji, discord.PartialEmoji]]
|
|
The emojis of which one we expect to be reacted.
|
|
message : discord.Message
|
|
Same as ``message`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
ReactionPredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(message, user)
|
|
|
|
def predicate(self: ReactionPredicate, r: discord.Reaction, u: discord.abc.User):
|
|
if not same_context(r, u):
|
|
return False
|
|
|
|
try:
|
|
self.result = emojis.index(r.emoji)
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|
|
|
|
@classmethod
|
|
def yes_or_no(
|
|
cls, message: Optional[discord.Message] = None, user: Optional[discord.abc.User] = None
|
|
) -> "ReactionPredicate":
|
|
"""Match if the reaction is a tick or cross emoji.
|
|
|
|
The emojis used are in
|
|
`ReactionPredicate.YES_OR_NO_EMOJIS`.
|
|
|
|
This will assign ``True`` for *yes*, or ``False`` for *no* to
|
|
the `result` attribute.
|
|
|
|
Parameters
|
|
----------
|
|
message : discord.Message
|
|
Same as ``message`` in :meth:`same_context`.
|
|
user : Optional[discord.abc.User]
|
|
Same as ``user`` in :meth:`same_context`.
|
|
|
|
Returns
|
|
-------
|
|
ReactionPredicate
|
|
The event predicate.
|
|
|
|
"""
|
|
same_context = cls.same_context(message, user)
|
|
|
|
def predicate(self: ReactionPredicate, r: discord.Reaction, u: discord.abc.User) -> bool:
|
|
if not same_context(r, u):
|
|
return False
|
|
|
|
try:
|
|
self.result = not bool(self.YES_OR_NO_EMOJIS.index(r.emoji))
|
|
except ValueError:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
return cls(predicate)
|