Merge remote-tracking branch 'origin/main' into filters/autoban

Author: Akarys42

bot/converters.py

@@ -2,7 +2,7 @@
 
 import re
 import typing as t
-from datetime import datetime
+from datetime import datetime, timezone
 from ssl import CertificateError
 
 import dateutil.parser
@@ -11,7 +11,7 @@
 from aiohttp import ClientConnectorError
 from dateutil.relativedelta import relativedelta
 from discord.ext.commands import BadArgument, Bot, Context, Converter, IDConverter, MemberConverter, UserConverter
-from discord.utils import DISCORD_EPOCH, escape_markdown, snowflake_time
+from discord.utils import escape_markdown, snowflake_time
 
 from bot import exts
 from bot.api import ResponseCodeError
@@ -28,7 +28,7 @@
 
 log = get_logger(__name__)
 
-DISCORD_EPOCH_DT = datetime.utcfromtimestamp(DISCORD_EPOCH / 1000)
+DISCORD_EPOCH_DT = snowflake_time(0)
 RE_USER_MENTION = re.compile(r"<@!?([0-9]+)>$")
 
 
@@ -71,10 +71,10 @@ class ValidDiscordServerInvite(Converter):
 
     async def convert(self, ctx: Context, server_invite: str) -> dict:
         """Check whether the string is a valid Discord server invite."""
-        invite_code = INVITE_RE.search(server_invite)
+        invite_code = INVITE_RE.match(server_invite)
         if invite_code:
             response = await ctx.bot.http_session.get(
-                f"{URLs.discord_invite_api}/{invite_code[1]}"
+                f"{URLs.discord_invite_api}/{invite_code.group('invite')}"
             )
             if response.status != 404:
                 invite_data = await response.json()
@@ -273,14 +273,14 @@ async def convert(self, ctx: Context, arg: str) -> int:
         snowflake = int(arg)
 
         try:
-            time = snowflake_time(snowflake).replace(tzinfo=None)
+            time = snowflake_time(snowflake)
         except (OverflowError, OSError) as e:
             # Not sure if this can ever even happen, but let's be safe.
             raise BadArgument(f"{error}: {e}")
 
         if time < DISCORD_EPOCH_DT:
             raise BadArgument(f"{error}: timestamp is before the Discord epoch.")
-        elif (datetime.utcnow() - time).days < -1:
+        elif (datetime.now(timezone.utc) - time).days < -1:
             raise BadArgument(f"{error}: timestamp is too far into the future.")
 
         return snowflake
@@ -387,7 +387,7 @@ async def convert(self, ctx: Context, duration: str) -> datetime:
         The converter supports the same symbols for each unit of time as its parent class.
         """
         delta = await super().convert(ctx, duration)
-        now = datetime.utcnow()
+        now = datetime.now(timezone.utc)
 
         try:
             return now + delta
@@ -443,8 +443,8 @@ async def convert(self, ctx: Context, datetime_string: str) -> datetime:
         The converter is flexible in the formats it accepts, as it uses the `isoparse` method of
         `dateutil.parser`. In general, it accepts datetime strings that start with a date,
         optionally followed by a time. Specifying a timezone offset in the datetime string is
-        supported, but the `datetime` object will be converted to UTC and will be returned without
-        `tzinfo` as a timezone-unaware `datetime` object.
+        supported, but the `datetime` object will be converted to UTC. If no timezone is specified, the datetime will
+        be assumed to be in UTC already. In all cases, the returned object will have the UTC timezone.
 
         See: https://dateutil.readthedocs.io/en/stable/parser.html#dateutil.parser.isoparse
 
@@ -470,7 +470,8 @@ async def convert(self, ctx: Context, datetime_string: str) -> datetime:
 
         if dt.tzinfo:
             dt = dt.astimezone(dateutil.tz.UTC)
-            dt = dt.replace(tzinfo=None)
+        else:  # Without a timezone, assume it represents UTC.
+            dt = dt.replace(tzinfo=dateutil.tz.UTC)
 
         return dt
 

bot/exts/backend/error_handler.py

@@ -59,17 +59,23 @@ async def on_command_error(self, ctx: Context, e: errors.CommandError) -> None:
             log.trace(f"Command {command} had its error already handled locally; ignoring.")
             return
 
+        debug_message = (
+            f"Command {command} invoked by {ctx.message.author} with error "
+            f"{e.__class__.__name__}: {e}"
+        )
+
         if isinstance(e, errors.CommandNotFound) and not getattr(ctx, "invoked_from_error_handler", False):
             if await self.try_silence(ctx):
                 return
-            # Try to look for a tag with the command's name
-            await self.try_get_tag(ctx)
-            return  # Exit early to avoid logging.
+            await self.try_get_tag(ctx)  # Try to look for a tag with the command's name
         elif isinstance(e, errors.UserInputError):
+            log.debug(debug_message)
             await self.handle_user_input_error(ctx, e)
         elif isinstance(e, errors.CheckFailure):
+            log.debug(debug_message)
             await self.handle_check_failure(ctx, e)
         elif isinstance(e, errors.CommandOnCooldown):
+            log.debug(debug_message)
             await ctx.send(e)
         elif isinstance(e, errors.CommandInvokeError):
             if isinstance(e.original, ResponseCodeError):
@@ -80,22 +86,16 @@ async def on_command_error(self, ctx: Context, e: errors.CommandError) -> None:
                 await ctx.send(f"Cannot infract that user. {e.original.reason}")
             else:
                 await self.handle_unexpected_error(ctx, e.original)
-            return  # Exit early to avoid logging.
         elif isinstance(e, errors.ConversionError):
             if isinstance(e.original, ResponseCodeError):
                 await self.handle_api_error(ctx, e.original)
             else:
                 await self.handle_unexpected_error(ctx, e.original)
-            return  # Exit early to avoid logging.
-        elif not isinstance(e, errors.DisabledCommand):
+        elif isinstance(e, errors.DisabledCommand):
+            log.debug(debug_message)
+        else:
             # MaxConcurrencyReached, ExtensionError
             await self.handle_unexpected_error(ctx, e)
-            return  # Exit early to avoid logging.
-
-        log.debug(
-            f"Command {command} invoked by {ctx.message.author} with error "
-            f"{e.__class__.__name__}: {e}"
-        )
 
     @staticmethod
     def get_help_command(ctx: Context) -> t.Coroutine:
@@ -188,9 +188,6 @@ async def try_get_tag(self, ctx: Context) -> None:
         if not any(role.id in MODERATION_ROLES for role in ctx.author.roles):
             await self.send_command_suggestion(ctx, ctx.invoked_with)
 
-        # Return to not raise the exception
-        return
-
     async def send_command_suggestion(self, ctx: Context, command_name: str) -> None:
         """Sends user similar commands if any can be found."""
         # No similar tag found, or tag on cooldown -
@@ -235,38 +232,32 @@ async def handle_user_input_error(self, ctx: Context, e: errors.UserInputError)
         """
         if isinstance(e, errors.MissingRequiredArgument):
             embed = self._get_error_embed("Missing required argument", e.param.name)
-            await ctx.send(embed=embed)
-            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.missing_required_argument")
         elif isinstance(e, errors.TooManyArguments):
             embed = self._get_error_embed("Too many arguments", str(e))
-            await ctx.send(embed=embed)
-            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.too_many_arguments")
         elif isinstance(e, errors.BadArgument):
             embed = self._get_error_embed("Bad argument", str(e))
-            await ctx.send(embed=embed)
-            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.bad_argument")
         elif isinstance(e, errors.BadUnionArgument):
             embed = self._get_error_embed("Bad argument", f"{e}\n{e.errors[-1]}")
-            await ctx.send(embed=embed)
-            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.bad_union_argument")
         elif isinstance(e, errors.ArgumentParsingError):
             embed = self._get_error_embed("Argument parsing error", str(e))
             await ctx.send(embed=embed)
             self.get_help_command(ctx).close()
             self.bot.stats.incr("errors.argument_parsing_error")
+            return
         else:
             embed = self._get_error_embed(
                 "Input error",
                 "Something about your input seems off. Check the arguments and try again."
             )
-            await ctx.send(embed=embed)
-            await self.get_help_command(ctx)
             self.bot.stats.incr("errors.other_user_input_error")
 
+        await ctx.send(embed=embed)
+        await self.get_help_command(ctx)
+
     @staticmethod
     async def handle_check_failure(ctx: Context, e: errors.CheckFailure) -> None:
         """
@@ -299,21 +290,21 @@ async def handle_check_failure(ctx: Context, e: errors.CheckFailure) -> None:
     async def handle_api_error(ctx: Context, e: ResponseCodeError) -> None:
         """Send an error message in `ctx` for ResponseCodeError and log it."""
         if e.status == 404:
-            await ctx.send("There does not seem to be anything matching your query.")
             log.debug(f"API responded with 404 for command {ctx.command}")
+            await ctx.send("There does not seem to be anything matching your query.")
             ctx.bot.stats.incr("errors.api_error_404")
         elif e.status == 400:
             content = await e.response.json()
             log.debug(f"API responded with 400 for command {ctx.command}: %r.", content)
             await ctx.send("According to the API, your request is malformed.")
             ctx.bot.stats.incr("errors.api_error_400")
         elif 500 <= e.status < 600:
-            await ctx.send("Sorry, there seems to be an internal issue with the API.")
             log.warning(f"API responded with {e.status} for command {ctx.command}")
+            await ctx.send("Sorry, there seems to be an internal issue with the API.")
             ctx.bot.stats.incr("errors.api_internal_server_error")
         else:
-            await ctx.send(f"Got an unexpected status code from the API (`{e.status}`).")
             log.warning(f"Unexpected API response for command {ctx.command}: {e.status}")
+            await ctx.send(f"Got an unexpected status code from the API (`{e.status}`).")
             ctx.bot.stats.incr(f"errors.api_error_{e.status}")
 
     @staticmethod

bot/exts/filters/antispam.py

@@ -2,11 +2,12 @@
 from collections import defaultdict
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import timedelta
 from itertools import takewhile
 from operator import attrgetter, itemgetter
 from typing import Dict, Iterable, List, Set
 
+import arrow
 from discord import Colour, Member, Message, NotFound, Object, TextChannel
 from discord.ext.commands import Cog
 
@@ -177,21 +178,17 @@ async def on_message(self, message: Message) -> None:
 
         self.cache.append(message)
 
-        earliest_relevant_at = datetime.utcnow() - timedelta(seconds=self.max_interval)
-        relevant_messages = list(
-            takewhile(lambda msg: msg.created_at.replace(tzinfo=None) > earliest_relevant_at, self.cache)
-        )
+        earliest_relevant_at = arrow.utcnow() - timedelta(seconds=self.max_interval)
+        relevant_messages = list(takewhile(lambda msg: msg.created_at > earliest_relevant_at, self.cache))
 
         for rule_name in AntiSpamConfig.rules:
             rule_config = AntiSpamConfig.rules[rule_name]
             rule_function = RULE_FUNCTION_MAPPING[rule_name]
 
             # Create a list of messages that were sent in the interval that the rule cares about.
-            latest_interesting_stamp = datetime.utcnow() - timedelta(seconds=rule_config['interval'])
+            latest_interesting_stamp = arrow.utcnow() - timedelta(seconds=rule_config['interval'])
             messages_for_rule = list(
-                takewhile(
-                    lambda msg: msg.created_at.replace(tzinfo=None) > latest_interesting_stamp, relevant_messages
-                )
+                takewhile(lambda msg: msg.created_at > latest_interesting_stamp, relevant_messages)
             )
 
             result = await rule_function(message, messages_for_rule, rule_config)

bot/exts/filters/filtering.py

@@ -3,7 +3,8 @@
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Tuple, Union
 
-import dateutil
+import arrow
+import dateutil.parser
 import discord.errors
 import regex
 from async_rediscache import RedisCache
@@ -209,8 +210,8 @@ def get_name_matches(self, name: str) -> List[re.Match]:
     async def check_send_alert(self, member: Member) -> bool:
         """When there is less than 3 days after last alert, return `False`, otherwise `True`."""
         if last_alert := await self.name_alerts.get(member.id):
-            last_alert = datetime.utcfromtimestamp(last_alert)
-            if datetime.utcnow() - timedelta(days=DAYS_BETWEEN_ALERTS) < last_alert:
+            last_alert = arrow.get(last_alert)
+            if arrow.utcnow() - timedelta(days=DAYS_BETWEEN_ALERTS) < last_alert:
                 log.trace(f"Last alert was too recent for {member}'s nickname.")
                 return False
 
@@ -244,7 +245,7 @@ async def check_bad_words_in_name(self, member: Member) -> None:
             )
 
             # Update time when alert sent
-            await self.name_alerts.set(member.id, datetime.utcnow().timestamp())
+            await self.name_alerts.set(member.id, arrow.utcnow().timestamp())
 
     async def filter_eval(self, result: str, msg: Message) -> bool:
         """
@@ -543,7 +544,7 @@ async def _has_invites(self, text: str) -> Union[dict, bool]:
         # discord\.gg/gdudes-pony-farm
         text = text.replace("\\", "")
 
-        invites = INVITE_RE.findall(text)
+        invites = [m.group("invite") for m in INVITE_RE.finditer(text)]
         invite_data = dict()
         for invite in invites:
             if invite in invite_data:
@@ -639,25 +640,25 @@ async def notify_member(self, filtered_member: Member, reason: str, channel: Tex
 
     def schedule_msg_delete(self, msg: dict) -> None:
         """Delete an offensive message once its deletion date is reached."""
-        delete_at = dateutil.parser.isoparse(msg['delete_date']).replace(tzinfo=None)
+        delete_at = dateutil.parser.isoparse(msg['delete_date'])
         self.scheduler.schedule_at(delete_at, msg['id'], self.delete_offensive_msg(msg))
 
     async def reschedule_offensive_msg_deletion(self) -> None:
         """Get all the pending message deletion from the API and reschedule them."""
         await self.bot.wait_until_ready()
         response = await self.bot.api_client.get('bot/offensive-messages',)
 
-        now = datetime.utcnow()
+        now = arrow.utcnow()
 
         for msg in response:
-            delete_at = dateutil.parser.isoparse(msg['delete_date']).replace(tzinfo=None)
+            delete_at = dateutil.parser.isoparse(msg['delete_date'])
 
             if delete_at < now:
                 await self.delete_offensive_msg(msg)
             else:
                 self.schedule_msg_delete(msg)
 
-    async def delete_offensive_msg(self, msg: Mapping[str, str]) -> None:
+    async def delete_offensive_msg(self, msg: Mapping[str, int]) -> None:
         """Delete an offensive message, and then delete it from the db."""
         try:
             channel = self.bot.get_channel(msg['channel_id'])

bot/exts/fun/off_topic_names.py

@@ -1,6 +1,7 @@
 import difflib
-from datetime import datetime, timedelta
+from datetime import timedelta
 
+import arrow
 from discord import Colour, Embed
 from discord.ext.commands import Cog, Context, group, has_any_role
 from discord.utils import sleep_until
@@ -22,9 +23,9 @@ async def update_names(bot: Bot) -> None:
     while True:
         # Since we truncate the compute timedelta to seconds, we add one second to ensure
         # we go past midnight in the `seconds_to_sleep` set below.
-        today_at_midnight = datetime.utcnow().replace(microsecond=0, second=0, minute=0, hour=0)
+        today_at_midnight = arrow.utcnow().replace(microsecond=0, second=0, minute=0, hour=0)
         next_midnight = today_at_midnight + timedelta(days=1)
-        await sleep_until(next_midnight)
+        await sleep_until(next_midnight.datetime)
 
         try:
             channel_0_name, channel_1_name, channel_2_name = await bot.api_client.get(

bot/exts/help_channels/_cog.py

@@ -125,14 +125,21 @@ async def claim_channel(self, message: discord.Message) -> None:
         """
         log.info(f"Channel #{message.channel} was claimed by `{message.author.id}`.")
         await self.move_to_in_use(message.channel)
-        await self._handle_role_change(message.author, message.author.add_roles)
 
-        await _message.pin(message)
+        # Handle odd edge case of `message.author` not being a `discord.Member` (see bot#1839)
+        if not isinstance(message.author, discord.Member):
+            log.warning(
+                f"{message.author} ({message.author.id}) isn't a member. Not giving cooldown role or sending DM."
+            )
+        else:
+            await self._handle_role_change(message.author, message.author.add_roles)
 
-        try:
-            await _message.dm_on_open(message)
-        except Exception as e:
-            log.warning("Error occurred while sending DM:", exc_info=e)
+            try:
+                await _message.dm_on_open(message)
+            except Exception as e:
+                log.warning("Error occurred while sending DM:", exc_info=e)
+
+        await _message.pin(message)
 
         # Add user with channel for dormant check.
         await _caches.claimants.set(message.channel.id, message.author.id)