Add main application entry point and requirements file

.github/dependabot.yml

@@ -5,9 +5,10 @@ updates:
     schedule:
       interval: "daily"
     ignore:
-      update-types:
-        - sem-ver:patch
-        - sem-ver:minor
+      - dependency-name: "*"
+        update-types:
+          - version-update:semver-patch
+          - version-update:semver-minor
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:

.github/workflows/sentry_release.yml

@@ -12,7 +12,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Create a Sentry.io release
-        uses: getsentry/action-release@v1
+        uses: getsentry/action-release@v3
         env:
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: python-discord

bot/constants.py

@@ -160,6 +160,7 @@ class _Roles(EnvConfig, env_prefix="roles_"):
     mod_team: int = 267629731250176001
     owners: int = 267627879762755584
     project_leads: int = 815701647526330398
+    founders: int = 1069394343867199590
 
     # Code Jam
     jammers: int = 737249140966162473

bot/converters.py

@@ -13,10 +13,8 @@
 from discord.utils import snowflake_time
 from pydis_core.site_api import ResponseCodeError
 from pydis_core.utils import unqualify
-from pydis_core.utils.regex import DISCORD_INVITE
 
 from bot import exts, instance as bot_instance
-from bot.constants import URLs
 from bot.errors import InvalidInfractionError
 from bot.exts.info.doc import _inventory_parser
 from bot.log import get_logger
@@ -31,42 +29,6 @@
 RE_USER_MENTION = re.compile(r"<@!?([0-9]+)>$")
 
 
-class ValidDiscordServerInvite(Converter):
-    """
-    A converter that validates whether a given string is a valid Discord server invite.
-
-    Raises 'BadArgument' if:
-    - The string is not a valid Discord server invite.
-    - The string is valid, but is an invite for a group DM.
-    - The string is valid, but is expired.
-
-    Returns a (partial) guild object if:
-    - The string is a valid vanity
-    - The string is a full invite URI
-    - The string contains the invite code (the stuff after discord.gg/)
-
-    See the Discord API docs for documentation on the guild object:
-    https://discord.com/developers/docs/resources/guild#guild-object
-    """
-
-    async def convert(self, ctx: Context, server_invite: str) -> dict:
-        """Check whether the string is a valid Discord server invite."""
-        invite_code = DISCORD_INVITE.match(server_invite)
-        if invite_code:
-            response = await ctx.bot.http_session.get(
-                f"{URLs.discord_invite_api}/{invite_code.group('invite')}"
-            )
-            if response.status != 404:
-                invite_data = await response.json()
-                return invite_data.get("guild")
-
-        id_converter = IDConverter()
-        if id_converter._get_id_match(server_invite):
-            raise BadArgument("Guild IDs are not supported, only invites.")
-
-        raise BadArgument("This does not appear to be a valid Discord server invite.")
-
-
 class Extension(Converter):
     """
     Fully qualify the name of an extension and ensure it exists.
@@ -466,7 +428,6 @@ async def convert(self, ctx: Context, arg: str) -> dict | None:
 
 
 if t.TYPE_CHECKING:
-    ValidDiscordServerInvite = dict
     ValidFilterListType = str
     Extension = str
     PackageName = str

bot/exts/filtering/filtering.py

@@ -978,7 +978,10 @@ async def _resolve_action(
         result_actions = None
         if actions:
             result_actions = reduce(ActionSettings.union, actions)
-
+            # If the action is a ban, mods don't want to be pinged.
+            if infr_action := result_actions.get("infraction_and_notification"):
+                if infr_action.infraction_type == Infraction.BAN:
+                    result_actions.pop("mentions", None)
         return result_actions, messages, triggers
 
     async def _send_alert(self, ctx: FilterContext, triggered_filters: dict[FilterList, Iterable[str]]) -> None:

bot/exts/moderation/infraction/management.py

@@ -237,7 +237,7 @@ async def infraction_edit(
                     capped, duration = _utils.cap_timeout_duration(expiry)
                     if capped:
                         await _utils.notify_timeout_cap(self.bot, ctx, user)
-                    await user.edit(reason=reason, timed_out_until=expiry)
+                    await user.edit(reason=reason, timed_out_until=duration)
 
             log_text += f"""
                 Previous expiry: {time.until_expiration(infraction['expires_at'])}

bot/exts/recruitment/talentpool/_cog.py

@@ -137,13 +137,13 @@ async def nomination_group(self, ctx: Context) -> None:
         await ctx.send_help(ctx.command)
 
     @nomination_group.group(name="autoreview", aliases=("ar",), invoke_without_command=True)
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def nomination_autoreview_group(self, ctx: Context) -> None:
         """Commands for enabling or disabling autoreview."""
         await ctx.send_help(ctx.command)
 
     @nomination_autoreview_group.command(name="enable", aliases=("on",))
-    @has_any_role(Roles.admins)
+    @has_any_role(Roles.admins, Roles.founders)
     @commands.max_concurrency(1)
     async def autoreview_enable(self, ctx: Context) -> None:
         """
@@ -167,7 +167,7 @@ async def autoreview_enable(self, ctx: Context) -> None:
         await ctx.send(":white_check_mark: Autoreview enabled.")
 
     @nomination_autoreview_group.command(name="disable", aliases=("off",))
-    @has_any_role(Roles.admins)
+    @has_any_role(Roles.admins, Roles.founders)
     @commands.max_concurrency(1)
     async def autoreview_disable(self, ctx: Context) -> None:
         """Disable automatic posting of reviews."""
@@ -183,7 +183,7 @@ async def autoreview_disable(self, ctx: Context) -> None:
         await ctx.send(":white_check_mark: Autoreview disabled.")
 
     @nomination_autoreview_group.command(name="status")
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def autoreview_status(self, ctx: Context) -> None:
         """Show whether automatic posting of reviews is enabled or disabled."""
         if await self.autoreview_enabled():
@@ -246,7 +246,7 @@ async def prune_talentpool(self) -> None:
         aliases=("nominated", "nominees"),
         invoke_without_command=True
     )
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def list_group(
         self,
         ctx: Context,
@@ -553,7 +553,7 @@ async def _nominate_user(self, ctx: Context, user: MemberOrUser, reason: str) ->
         await self.maybe_relay_update(user.id, thread_update)
 
     @nomination_group.command(name="history", aliases=("info", "search"))
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def history_command(self, ctx: Context, user: MemberOrUser) -> None:
         """Shows the specified user's nomination history."""
         result = await self.api.get_nominations(user.id, ordering="-active,-inserted_at")
@@ -577,7 +577,7 @@ async def history_command(self, ctx: Context, user: MemberOrUser) -> None:
         )
 
     @nomination_group.command(name="end", aliases=("unwatch", "unnominate"), root_aliases=("unnominate",))
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def end_nomination_command(self, ctx: Context, user: MemberOrUser, *, reason: str) -> None:
         """
         Ends the active nomination of the specified user with the given reason.
@@ -769,7 +769,7 @@ async def _edit_nomination_reason(
         await self.maybe_relay_update(nomination.user_id, thread_update)
 
     @nomination_edit_group.command(name="end_reason")
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def edit_end_reason_command(self, ctx: Context, nomination_id: int, *, reason: str) -> None:
         """Edits the unnominate reason for the nomination with the given `id`."""
         if len(reason) > REASON_MAX_CHARS:
@@ -792,7 +792,7 @@ async def edit_end_reason_command(self, ctx: Context, nomination_id: int, *, rea
         await ctx.send(f":white_check_mark: Updated the nomination end reason for <@{nomination.user_id}>.")
 
     @nomination_group.command(aliases=("gr",))
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def get_review(self, ctx: Context, user_id: int) -> None:
         """Get the user's review as a markdown file."""
         nominations = await self.api.get_nominations(user_id, active=True)
@@ -808,7 +808,7 @@ async def get_review(self, ctx: Context, user_id: int) -> None:
         await ctx.send(files=[review_file, nominations_file])
 
     @nomination_group.command(aliases=("review",))
-    @has_any_role(*MODERATION_ROLES)
+    @has_any_role(*MODERATION_ROLES, Roles.founders)
     async def post_review(self, ctx: Context, user_id: int) -> None:
         """Post the automatic review for the user ahead of time."""
         nominations = await self.api.get_nominations(user_id, active=True)

bot/exts/utils/reminders.py

@@ -39,6 +39,10 @@
 WHITELISTED_CHANNELS = Guild.reminder_whitelist
 MAXIMUM_REMINDERS = 5
 REMINDER_EDIT_CONFIRMATION_TIMEOUT = 60
+REMINDER_MENTION_BUTTON_TIMEOUT = 5*60
+# The number of mentions that can be sent when a reminder arrives is limited by
+# the 2000-character message limit.
+MAXIMUM_REMINDER_MENTION_OPT_INS = 80
 
 Mentionable = discord.Member | discord.Role
 ReminderMention = UnambiguousUser | discord.Role
@@ -75,6 +79,137 @@ async def cancel(self, interaction: Interaction, button: discord.ui.Button) -> N
         self.stop()
 
 
+class OptInReminderMentionView(discord.ui.View):
+    """A button to opt-in to get notified of someone else's reminder."""
+
+    def __init__(self, cog: "Reminders", reminder: dict, expiration: Duration):
+        super().__init__()
+
+        self.cog = cog
+        self.reminder = reminder
+
+        self.timeout = min(
+            (expiration - datetime.now(UTC)).total_seconds(),
+            REMINDER_MENTION_BUTTON_TIMEOUT
+        )
+
+    async def get_embed(
+        self,
+        message: str = "Click on the button to add yourself to the list of mentions."
+    ) -> discord.Embed:
+        """Return an embed to show the button together with."""
+        description = "The following user(s) will be notified when the reminder arrives:\n"
+        description += " ".join([
+            mentionable.mention async for mentionable in self.cog.get_mentionables(
+                [self.reminder["author"]] + self.reminder["mentions"]
+            )
+        ])
+
+        if message:
+            description += f"\n\n{message}"
+
+        return discord.Embed(description=description)
+
+    @discord.ui.button(emoji="🔔", label="Notify me", style=discord.ButtonStyle.green)
+    async def button_callback(self, interaction: Interaction, button: discord.ui.Button) -> None:
+        """The button callback."""
+        # This is required in case the reminder was edited/deleted between
+        # creation and the opt-in button click.
+        try:
+            api_response = await self.cog.bot.api_client.get(f"bot/reminders/{self.reminder['id']}")
+        except ResponseCodeError as e:
+            await self.handle_api_error(interaction, button, e)
+            return
+
+        self.reminder = api_response
+
+        # Check whether the user should be added.
+        if interaction.user.id == self.reminder["author"]:
+            await interaction.response.send_message(
+                "As the author of that reminder, you will already be notified when the reminder arrives.",
+                ephemeral=True,
+            )
+            return
+
+        if interaction.user.id in self.reminder["mentions"]:
+            await interaction.response.send_message(
+                "You are already in the list of mentions for that reminder.",
+                ephemeral=True,
+                delete_after=5,
+            )
+            return
+
+        if len(self.reminder["mentions"]) >= MAXIMUM_REMINDER_MENTION_OPT_INS:
+            await interaction.response.send_message(
+                "Sorry, this reminder has reached the maximum number of allowed mentions.",
+                ephemeral=True,
+                delete_after=5,
+            )
+            await self.disable(interaction, button, "Maximum number of allowed mentions reached!")
+            return
+
+        # Add the user to the list of mentions.
+        try:
+            api_response = await self.cog.add_mention_opt_in(self.reminder, interaction.user.id)
+        except ResponseCodeError as e:
+            await self.handle_api_error(interaction, button, e)
+            return
+
+        self.reminder = api_response
+
+        # Confirm that it was successful.
+        await interaction.response.send_message(
+            "You were successfully added to the list of mentions for that reminder.",
+            ephemeral=True,
+            delete_after=5,
+        )
+
+        # Update the embed to show the new list of mentions.
+        await interaction.message.edit(embed=await self.get_embed())
+
+    async def handle_api_error(
+        self,
+        interaction: Interaction,
+        button: discord.ui.Button,
+        error: ResponseCodeError
+    ) -> None:
+        """Handle a ResponseCodeError from the API responsibly."""
+        log.trace(f"API returned {error.status} for reminder #{self.reminder['id']}.")
+
+        if error.status == 404:
+            # This might happen if the reminder was edited to arrive before the
+            # button was initially scheduled to timeout.
+            await interaction.response.send_message(
+                "This reminder was either deleted or has already arrived.",
+                ephemeral=True,
+                delete_after=5,
+            )
+            # Don't delete the whole interaction message here or the user will
+            # see the above response message seemingly without context.
+            await self.disable(interaction, button)
+
+        else:
+            await interaction.response.send_message(
+                "Sorry, an unexpected error occurred when performing this operation.\n"
+                "Please create your own reminder instead.",
+                ephemeral=True,
+                delete_after=5,
+            )
+            await self.disable(
+                interaction,
+                button,
+                "An unexpected error occurred when attempting to add users."
+            )
+
+    async def disable(self, interaction: Interaction, button: discord.ui.Button, reason: str = "") -> None:
+        """Disable the button and add an optional reason to the original interaction message."""
+        button.disabled = True
+        await interaction.message.edit(
+            embed=await self.get_embed(reason),
+            view=self,
+        )
+
+
 class Reminders(Cog):
     """Provide in-channel reminder functionality."""
 
@@ -207,6 +342,18 @@ async def _reschedule_reminder(self, reminder: dict) -> None:
         log.trace(f"Scheduling new task #{reminder['id']}")
         self.schedule_reminder(reminder)
 
+    @lock_arg(LOCK_NAMESPACE, "reminder", itemgetter("id"), raise_error=True)
+    async def add_mention_opt_in(self, reminder: dict, user_id: int) -> dict:
+        """Add an opt-in user to a reminder's mentions and return the edited reminder."""
+        if user_id in reminder["mentions"] or user_id == reminder["author"]:
+            return reminder
+
+        reminder["mentions"].append(user_id)
+        reminder = await self._edit_reminder(reminder["id"], {"mentions": reminder["mentions"]})
+
+        await self._reschedule_reminder(reminder)
+        return reminder
+
     @lock_arg(LOCK_NAMESPACE, "reminder", itemgetter("id"), raise_error=True)
     async def send_reminder(self, reminder: dict, expected_time: time.Timestamp | None = None) -> None:
         """Send the reminder."""
@@ -360,19 +507,19 @@ async def new_reminder(
         )
 
         formatted_time = time.discord_timestamp(expiration, time.TimestampFormats.DAY_TIME)
-        mention_string = f"Your reminder will arrive on {formatted_time}"
-
-        if mentions:
-            mention_string += f" and will mention {len(mentions)} other(s)"
-        mention_string += "!"
+        success_message = f"Your reminder will arrive on {formatted_time}!"
 
         # Confirm to the user that it worked.
         await self._send_confirmation(
             ctx,
-            on_success=mention_string,
+            on_success=success_message,
             reminder_id=reminder["id"]
         )
 
+        # Add a button for others to also get notified.
+        view = OptInReminderMentionView(self, reminder, expiration)
+        await ctx.send(embed=await view.get_embed(), view=view, delete_after=view.timeout)
+
         self.schedule_reminder(reminder)
 
     @remind_group.command(name="list")