From 6b280b19ed5c564e824e55a1ec9bb13120c0193d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 16:13:49 -0700
Subject: Time: remove RFC1123 support

It's not used anywhere and hasn't been for a very long time.
---
 bot/utils/time.py            | 6 ------
 tests/bot/utils/test_time.py | 7 -------
 2 files changed, 13 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index eaa9b72e9..545e50859 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -7,7 +7,6 @@ import arrow
 import dateutil.parser
 from dateutil.relativedelta import relativedelta
 
-RFC1123_FORMAT = "%a, %d %b %Y %H:%M:%S GMT"
 DISCORD_TIMESTAMP_REGEX = re.compile(r"<t:(\d+):f>")
 
 _DURATION_REGEX = re.compile(
@@ -167,11 +166,6 @@ def time_since(past_datetime: datetime.datetime) -> str:
     return discord_timestamp(past_datetime, TimestampFormats.RELATIVE)
 
 
-def parse_rfc1123(stamp: str) -> datetime.datetime:
-    """Parse RFC1123 time string into datetime."""
-    return datetime.datetime.strptime(stamp, RFC1123_FORMAT).replace(tzinfo=datetime.timezone.utc)
-
-
 def format_infraction(timestamp: str) -> str:
     """Format an infraction timestamp to a discord timestamp."""
     return discord_timestamp(dateutil.parser.isoparse(timestamp))
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index a3dcbfc0a..9c52fed27 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -43,13 +43,6 @@ class TimeTests(unittest.TestCase):
                 time.humanize_delta(relativedelta(days=2, hours=2), 'hours', max_units)
             self.assertEqual(str(error.exception), 'max_units must be positive')
 
-    def test_parse_rfc1123(self):
-        """Testing parse_rfc1123."""
-        self.assertEqual(
-            time.parse_rfc1123('Sun, 15 Sep 2019 12:00:00 GMT'),
-            datetime(2019, 9, 15, 12, 0, 0, tzinfo=timezone.utc)
-        )
-
     def test_format_infraction(self):
         """Testing format_infraction."""
         self.assertEqual(time.format_infraction('2019-12-12T00:01:00Z'), '<t:1576108860:f>')
-- 
cgit v1.2.3


From 469cd57693925e78bef6a1163b620a39da208670 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 16:27:13 -0700
Subject: Time: qualify uses of functions with the module name

In cases where many time utility functions were being imported, this
makes the imports shorter and cleaner. In other cases, the function
names read better when they're qualified with "time"; the extra context
it adds is helpful.
---
 bot/converters.py                                  |  4 +--
 bot/exts/info/information.py                       | 10 ++++----
 bot/exts/moderation/defcon.py                      | 29 +++++++++++-----------
 bot/exts/moderation/infraction/management.py       |  7 +++---
 bot/exts/moderation/infraction/superstarify.py     |  6 ++---
 bot/exts/moderation/modlog.py                      |  6 ++---
 bot/exts/moderation/modpings.py                    |  7 +++---
 bot/exts/moderation/stream.py                      |  7 +++---
 bot/exts/moderation/watchchannels/_watchchannel.py |  7 +++---
 bot/exts/recruitment/talentpool/_cog.py            |  3 +--
 bot/exts/recruitment/talentpool/_review.py         |  8 +++---
 bot/exts/utils/reminders.py                        | 10 ++++----
 bot/exts/utils/utils.py                            |  5 ++--
 13 files changed, 51 insertions(+), 58 deletions(-)

diff --git a/bot/converters.py b/bot/converters.py
index 559e759e1..b68c4d623 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -20,9 +20,9 @@ from bot.errors import InvalidInfraction
 from bot.exts.info.doc import _inventory_parser
 from bot.exts.info.tags import TagIdentifier
 from bot.log import get_logger
+from bot.utils import time
 from bot.utils.extensions import EXTENSIONS, unqualify
 from bot.utils.regex import INVITE_RE
-from bot.utils.time import parse_duration_string
 
 if t.TYPE_CHECKING:
     from bot.exts.info.source import SourceType
@@ -338,7 +338,7 @@ class DurationDelta(Converter):
 
         The units need to be provided in descending order of magnitude.
         """
-        if not (delta := parse_duration_string(duration)):
+        if not (delta := time.parse_duration_string(duration)):
             raise BadArgument(f"`{duration}` is not a valid duration string.")
 
         return delta
diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index 1f95c460f..a83ce4d53 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -18,10 +18,10 @@ from bot.decorators import in_whitelist
 from bot.errors import NonExistentRoleError
 from bot.log import get_logger
 from bot.pagination import LinePaginator
+from bot.utils import time
 from bot.utils.channel import is_mod_channel, is_staff_channel
 from bot.utils.checks import cooldown_with_role_bypass, has_no_roles_check, in_whitelist_check
 from bot.utils.members import get_or_fetch_member
-from bot.utils.time import TimestampFormats, discord_timestamp, humanize_delta
 
 log = get_logger(__name__)
 
@@ -83,7 +83,7 @@ class Information(Cog):
 
         defcon_info = ""
         if cog := self.bot.get_cog("Defcon"):
-            threshold = humanize_delta(cog.threshold) if cog.threshold else "-"
+            threshold = time.humanize_delta(cog.threshold) if cog.threshold else "-"
             defcon_info = f"Defcon threshold: {threshold}\n"
 
         verification = f"Verification level: {ctx.guild.verification_level.name}\n"
@@ -173,7 +173,7 @@ class Information(Cog):
         """Returns an embed full of server information."""
         embed = Embed(colour=Colour.og_blurple(), title="Server Information")
 
-        created = discord_timestamp(ctx.guild.created_at, TimestampFormats.RELATIVE)
+        created = time.discord_timestamp(ctx.guild.created_at, time.TimestampFormats.RELATIVE)
         num_roles = len(ctx.guild.roles) - 1  # Exclude @everyone
 
         # Server Features are only useful in certain channels
@@ -249,7 +249,7 @@ class Information(Cog):
         """Creates an embed containing information on the `user`."""
         on_server = bool(await get_or_fetch_member(ctx.guild, user.id))
 
-        created = discord_timestamp(user.created_at, TimestampFormats.RELATIVE)
+        created = time.discord_timestamp(user.created_at, time.TimestampFormats.RELATIVE)
 
         name = str(user)
         if on_server and user.nick:
@@ -272,7 +272,7 @@ class Information(Cog):
 
         if on_server:
             if user.joined_at:
-                joined = discord_timestamp(user.joined_at, TimestampFormats.RELATIVE)
+                joined = time.discord_timestamp(user.joined_at, time.TimestampFormats.RELATIVE)
             else:
                 joined = "Unable to get join date"
 
diff --git a/bot/exts/moderation/defcon.py b/bot/exts/moderation/defcon.py
index 14db37367..048e0f990 100644
--- a/bot/exts/moderation/defcon.py
+++ b/bot/exts/moderation/defcon.py
@@ -17,12 +17,9 @@ from bot.constants import Channels, Colours, Emojis, Event, Icons, MODERATION_RO
 from bot.converters import DurationDelta, Expiry
 from bot.exts.moderation.modlog import ModLog
 from bot.log import get_logger
-from bot.utils import scheduling
+from bot.utils import scheduling, time
 from bot.utils.messages import format_user
 from bot.utils.scheduling import Scheduler
-from bot.utils.time import (
-    TimestampFormats, discord_timestamp, humanize_delta, parse_duration_string, relativedelta_to_timedelta
-)
 
 log = get_logger(__name__)
 
@@ -88,7 +85,7 @@ class Defcon(Cog):
 
         try:
             settings = await self.defcon_settings.to_dict()
-            self.threshold = parse_duration_string(settings["threshold"]) if settings.get("threshold") else None
+            self.threshold = time.parse_duration_string(settings["threshold"]) if settings.get("threshold") else None
             self.expiry = datetime.fromisoformat(settings["expiry"]) if settings.get("expiry") else None
         except RedisError:
             log.exception("Unable to get DEFCON settings!")
@@ -102,7 +99,7 @@ class Defcon(Cog):
                 self.scheduler.schedule_at(self.expiry, 0, self._remove_threshold())
 
             self._update_notifier()
-            log.info(f"DEFCON synchronized: {humanize_delta(self.threshold) if self.threshold else '-'}")
+            log.info(f"DEFCON synchronized: {time.humanize_delta(self.threshold) if self.threshold else '-'}")
 
         self._update_channel_topic()
 
@@ -112,7 +109,7 @@ class Defcon(Cog):
         if self.threshold:
             now = arrow.utcnow()
 
-            if now - member.created_at < relativedelta_to_timedelta(self.threshold):
+            if now - member.created_at < time.relativedelta_to_timedelta(self.threshold):
                 log.info(f"Rejecting user {member}: Account is too new")
 
                 message_sent = False
@@ -151,11 +148,12 @@ class Defcon(Cog):
     @has_any_role(*MODERATION_ROLES)
     async def status(self, ctx: Context) -> None:
         """Check the current status of DEFCON mode."""
+        expiry = time.discord_timestamp(self.expiry, time.TimestampFormats.RELATIVE) if self.expiry else "-"
         embed = Embed(
             colour=Colour.og_blurple(), title="DEFCON Status",
             description=f"""
-                **Threshold:** {humanize_delta(self.threshold) if self.threshold else "-"}
-                **Expires:** {discord_timestamp(self.expiry, TimestampFormats.RELATIVE) if self.expiry else "-"}
+                **Threshold:** {time.humanize_delta(self.threshold) if self.threshold else "-"}
+                **Expires:** {expiry}
                 **Verification level:** {ctx.guild.verification_level.name}
                 """
         )
@@ -213,7 +211,8 @@ class Defcon(Cog):
 
     def _update_channel_topic(self) -> None:
         """Update the #defcon channel topic with the current DEFCON status."""
-        new_topic = f"{BASE_CHANNEL_TOPIC}\n(Threshold: {humanize_delta(self.threshold) if self.threshold else '-'})"
+        threshold = time.humanize_delta(self.threshold) if self.threshold else '-'
+        new_topic = f"{BASE_CHANNEL_TOPIC}\n(Threshold: {threshold})"
 
         self.mod_log.ignore(Event.guild_channel_update, Channels.defcon)
         scheduling.create_task(self.channel.edit(topic=new_topic))
@@ -256,11 +255,11 @@ class Defcon(Cog):
         expiry_message = ""
         if expiry:
             activity_duration = relativedelta(expiry, arrow.utcnow().datetime)
-            expiry_message = f" for the next {humanize_delta(activity_duration, max_units=2)}"
+            expiry_message = f" for the next {time.humanize_delta(activity_duration, max_units=2)}"
 
         if self.threshold:
             channel_message = (
-                f"updated; accounts must be {humanize_delta(self.threshold)} "
+                f"updated; accounts must be {time.humanize_delta(self.threshold)} "
                 f"old to join the server{expiry_message}"
             )
         else:
@@ -290,7 +289,7 @@ class Defcon(Cog):
 
     def _log_threshold_stat(self, threshold: relativedelta) -> None:
         """Adds the threshold to the bot stats in days."""
-        threshold_days = relativedelta_to_timedelta(threshold).total_seconds() / SECONDS_IN_DAY
+        threshold_days = time.relativedelta_to_timedelta(threshold).total_seconds() / SECONDS_IN_DAY
         self.bot.stats.gauge("defcon.threshold", threshold_days)
 
     async def _send_defcon_log(self, action: Action, actor: User) -> None:
@@ -298,7 +297,7 @@ class Defcon(Cog):
         info = action.value
         log_msg: str = (
             f"**Staffer:** {actor.mention} {actor} (`{actor.id}`)\n"
-            f"{info.template.format(threshold=(humanize_delta(self.threshold) if self.threshold else '-'))}"
+            f"{info.template.format(threshold=(time.humanize_delta(self.threshold) if self.threshold else '-'))}"
         )
         status_msg = f"DEFCON {action.name.lower()}"
 
@@ -317,7 +316,7 @@ class Defcon(Cog):
     @tasks.loop(hours=1)
     async def defcon_notifier(self) -> None:
         """Routinely notify moderators that DEFCON is active."""
-        await self.channel.send(f"Defcon is on and is set to {humanize_delta(self.threshold)}.")
+        await self.channel.send(f"Defcon is on and is set to {time.humanize_delta(self.threshold)}.")
 
     def cog_unload(self) -> None:
         """Cancel the notifer and threshold removal tasks when the cog unloads."""
diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 9649ff852..fb5af9eaa 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -20,7 +20,6 @@ from bot.pagination import LinePaginator
 from bot.utils import messages, time
 from bot.utils.channel import is_mod_channel
 from bot.utils.members import get_or_fetch_member
-from bot.utils.time import humanize_delta, until_expiration
 
 log = get_logger(__name__)
 
@@ -183,8 +182,8 @@ class ModManagement(commands.Cog):
                 self.infractions_cog.schedule_expiration(new_infraction)
 
             log_text += f"""
-                Previous expiry: {until_expiration(infraction['expires_at']) or "Permanent"}
-                New expiry: {until_expiration(new_infraction['expires_at']) or "Permanent"}
+                Previous expiry: {time.until_expiration(infraction['expires_at']) or "Permanent"}
+                New expiry: {time.until_expiration(new_infraction['expires_at']) or "Permanent"}
             """.rstrip()
 
         changes = ' & '.join(confirm_messages)
@@ -377,7 +376,7 @@ class ModManagement(commands.Cog):
                 timezone.utc
             )
             date_to = dateutil.parser.isoparse(expires_at)
-            duration = humanize_delta(relativedelta(date_to, date_from))
+            duration = time.humanize_delta(relativedelta(date_to, date_from))
 
         # Format `dm_sent`
         if dm_sent is None:
diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 08c92b8f3..2e272dbb0 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -14,9 +14,9 @@ from bot.converters import Duration, Expiry
 from bot.exts.moderation.infraction import _utils
 from bot.exts.moderation.infraction._scheduler import InfractionScheduler
 from bot.log import get_logger
+from bot.utils import time
 from bot.utils.members import get_or_fetch_member
 from bot.utils.messages import format_user
-from bot.utils.time import format_infraction
 
 log = get_logger(__name__)
 NICKNAME_POLICY_URL = "https://pythondiscord.com/pages/rules/#nickname-policy"
@@ -73,7 +73,7 @@ class Superstarify(InfractionScheduler, Cog):
         notified = await _utils.notify_infraction(
             user=after,
             infr_type="Superstarify",
-            expires_at=format_infraction(infraction["expires_at"]),
+            expires_at=time.format_infraction(infraction["expires_at"]),
             reason=(
                 "You have tried to change your nickname on the **Python Discord** server "
                 f"from **{before.display_name}** to **{after.display_name}**, but as you "
@@ -150,7 +150,7 @@ class Superstarify(InfractionScheduler, Cog):
         id_ = infraction["id"]
 
         forced_nick = self.get_nick(id_, member.id)
-        expiry_str = format_infraction(infraction["expires_at"])
+        expiry_str = time.format_infraction(infraction["expires_at"])
 
         # Apply the infraction
         async def action() -> None:
diff --git a/bot/exts/moderation/modlog.py b/bot/exts/moderation/modlog.py
index fc9204998..d5e209d81 100644
--- a/bot/exts/moderation/modlog.py
+++ b/bot/exts/moderation/modlog.py
@@ -16,8 +16,8 @@ from discord.utils import escape_markdown
 from bot.bot import Bot
 from bot.constants import Categories, Channels, Colours, Emojis, Event, Guild as GuildConstant, Icons, Roles, URLs
 from bot.log import get_logger
+from bot.utils import time
 from bot.utils.messages import format_user
-from bot.utils.time import humanize_delta
 
 log = get_logger(__name__)
 
@@ -407,7 +407,7 @@ class ModLog(Cog, name="ModLog"):
         now = datetime.now(timezone.utc)
         difference = abs(relativedelta(now, member.created_at))
 
-        message = format_user(member) + "\n\n**Account age:** " + humanize_delta(difference)
+        message = format_user(member) + "\n\n**Account age:** " + time.humanize_delta(difference)
 
         if difference.days < 1 and difference.months < 1 and difference.years < 1:  # New user account!
             message = f"{Emojis.new} {message}"
@@ -713,7 +713,7 @@ class ModLog(Cog, name="ModLog"):
             # datetime as the baseline and create a human-readable delta between this edit event
             # and the last time the message was edited
             timestamp = msg_before.edited_at
-            delta = humanize_delta(relativedelta(msg_after.edited_at, msg_before.edited_at))
+            delta = time.humanize_delta(relativedelta(msg_after.edited_at, msg_before.edited_at))
             footer = f"Last edited {delta} ago"
         else:
             # Message was not previously edited, use the created_at datetime as the baseline, no
diff --git a/bot/exts/moderation/modpings.py b/bot/exts/moderation/modpings.py
index 20a8c39d7..b5cd29b12 100644
--- a/bot/exts/moderation/modpings.py
+++ b/bot/exts/moderation/modpings.py
@@ -11,9 +11,8 @@ from bot.bot import Bot
 from bot.constants import Colours, Emojis, Guild, Icons, MODERATION_ROLES, Roles
 from bot.converters import Expiry
 from bot.log import get_logger
-from bot.utils import scheduling
+from bot.utils import scheduling, time
 from bot.utils.scheduling import Scheduler
-from bot.utils.time import TimestampFormats, discord_timestamp
 
 log = get_logger(__name__)
 
@@ -233,8 +232,8 @@ class ModPings(Cog):
 
         await ctx.send(
             f"{Emojis.ok_hand} {ctx.author.mention} Scheduled mod pings from "
-            f"{discord_timestamp(start, TimestampFormats.TIME)} to "
-            f"{discord_timestamp(end, TimestampFormats.TIME)}!"
+            f"{time.discord_timestamp(start, time.TimestampFormats.TIME)} to "
+            f"{time.discord_timestamp(end, time.TimestampFormats.TIME)}!"
         )
 
     @schedule_modpings.command(name='delete', aliases=('del', 'd'))
diff --git a/bot/exts/moderation/stream.py b/bot/exts/moderation/stream.py
index 99bbd8721..5a7b12295 100644
--- a/bot/exts/moderation/stream.py
+++ b/bot/exts/moderation/stream.py
@@ -14,9 +14,8 @@ from bot.constants import (
 from bot.converters import Expiry
 from bot.log import get_logger
 from bot.pagination import LinePaginator
-from bot.utils import scheduling
+from bot.utils import scheduling, time
 from bot.utils.members import get_or_fetch_member
-from bot.utils.time import discord_timestamp, format_infraction_with_duration
 
 log = get_logger(__name__)
 
@@ -131,10 +130,10 @@ class Stream(commands.Cog):
 
         await member.add_roles(discord.Object(Roles.video), reason="Temporary streaming access granted")
 
-        await ctx.send(f"{Emojis.check_mark} {member.mention} can now stream until {discord_timestamp(duration)}.")
+        await ctx.send(f"{Emojis.check_mark} {member.mention} can now stream until {time.discord_timestamp(duration)}.")
 
         # Convert here for nicer logging
-        revoke_time = format_infraction_with_duration(str(duration))
+        revoke_time = time.format_infraction_with_duration(str(duration))
         log.debug(f"Successfully gave {member} ({member.id}) permission to stream until {revoke_time}.")
 
     @commands.command(aliases=("pstream",))
diff --git a/bot/exts/moderation/watchchannels/_watchchannel.py b/bot/exts/moderation/watchchannels/_watchchannel.py
index 34d445912..106483527 100644
--- a/bot/exts/moderation/watchchannels/_watchchannel.py
+++ b/bot/exts/moderation/watchchannels/_watchchannel.py
@@ -18,9 +18,8 @@ from bot.exts.filters.webhook_remover import WEBHOOK_URL_RE
 from bot.exts.moderation.modlog import ModLog
 from bot.log import CustomLogger, get_logger
 from bot.pagination import LinePaginator
-from bot.utils import CogABCMeta, messages, scheduling
+from bot.utils import CogABCMeta, messages, scheduling, time
 from bot.utils.members import get_or_fetch_member
-from bot.utils.time import get_time_delta
 
 log = get_logger(__name__)
 
@@ -286,7 +285,7 @@ class WatchChannel(metaclass=CogABCMeta):
         actor = actor.display_name if actor else self.watched_users[user_id]['actor']
 
         inserted_at = self.watched_users[user_id]['inserted_at']
-        time_delta = get_time_delta(inserted_at)
+        time_delta = time.get_time_delta(inserted_at)
 
         reason = self.watched_users[user_id]['reason']
 
@@ -360,7 +359,7 @@ class WatchChannel(metaclass=CogABCMeta):
             if member:
                 line += f" ({member.name}#{member.discriminator})"
             inserted_at = user_data['inserted_at']
-            line += f", added {get_time_delta(inserted_at)}"
+            line += f", added {time.get_time_delta(inserted_at)}"
             if not member:  # Cross off users who left the server.
                 line = f"~~{line}~~"
             list_data["info"][user_id] = line
diff --git a/bot/exts/recruitment/talentpool/_cog.py b/bot/exts/recruitment/talentpool/_cog.py
index 8fa0be5b1..80274eaea 100644
--- a/bot/exts/recruitment/talentpool/_cog.py
+++ b/bot/exts/recruitment/talentpool/_cog.py
@@ -17,7 +17,6 @@ from bot.log import get_logger
 from bot.pagination import LinePaginator
 from bot.utils import scheduling, time
 from bot.utils.members import get_or_fetch_member
-from bot.utils.time import get_time_delta
 
 AUTOREVIEW_ENABLED_KEY = "autoreview_enabled"
 REASON_MAX_CHARS = 1000
@@ -181,7 +180,7 @@ class TalentPool(Cog, name="Talentpool"):
             if member:
                 line += f" ({member.name}#{member.discriminator})"
             inserted_at = user_data['inserted_at']
-            line += f", added {get_time_delta(inserted_at)}"
+            line += f", added {time.get_time_delta(inserted_at)}"
             if not member:  # Cross off users who left the server.
                 line = f"~~{line}~~"
             if user_data['reviewed']:
diff --git a/bot/exts/recruitment/talentpool/_review.py b/bot/exts/recruitment/talentpool/_review.py
index 0e7194892..bbffbe6e3 100644
--- a/bot/exts/recruitment/talentpool/_review.py
+++ b/bot/exts/recruitment/talentpool/_review.py
@@ -17,10 +17,10 @@ from bot.api import ResponseCodeError
 from bot.bot import Bot
 from bot.constants import Channels, Colours, Emojis, Guild, Roles
 from bot.log import get_logger
+from bot.utils import time
 from bot.utils.members import get_or_fetch_member
 from bot.utils.messages import count_unique_users_reaction, pin_no_system_message
 from bot.utils.scheduling import Scheduler
-from bot.utils.time import get_time_delta, time_since
 
 if typing.TYPE_CHECKING:
     from bot.exts.recruitment.talentpool._cog import TalentPool
@@ -273,7 +273,7 @@ class Reviewer:
                 last_channel = user_activity["top_channel_activity"][-1]
                 channels += f", and {last_channel[1]} in {last_channel[0]}"
 
-        joined_at_formatted = time_since(member.joined_at)
+        joined_at_formatted = time.time_since(member.joined_at)
         review = (
             f"{member.name} joined the server **{joined_at_formatted}**"
             f" and has **{messages} messages**{channels}."
@@ -321,7 +321,7 @@ class Reviewer:
             infractions += ", with the last infraction issued "
 
         # Infractions were ordered by time since insertion descending.
-        infractions += get_time_delta(infraction_list[0]['inserted_at'])
+        infractions += time.get_time_delta(infraction_list[0]['inserted_at'])
 
         return f"They have {infractions}."
 
@@ -365,7 +365,7 @@ class Reviewer:
 
         nomination_times = f"{num_entries} times" if num_entries > 1 else "once"
         rejection_times = f"{len(history)} times" if len(history) > 1 else "once"
-        end_time = time_since(isoparse(history[0]['ended_at']))
+        end_time = time.time_since(isoparse(history[0]['ended_at']))
 
         review = (
             f"They were nominated **{nomination_times}** before"
diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
index 90677b2dd..dc7782727 100644
--- a/bot/exts/utils/reminders.py
+++ b/bot/exts/utils/reminders.py
@@ -13,13 +13,12 @@ from bot.constants import Guild, Icons, MODERATION_ROLES, POSITIVE_REPLIES, Role
 from bot.converters import Duration, UnambiguousUser
 from bot.log import get_logger
 from bot.pagination import LinePaginator
-from bot.utils import scheduling
+from bot.utils import scheduling, time
 from bot.utils.checks import has_any_role_check, has_no_roles_check
 from bot.utils.lock import lock_arg
 from bot.utils.members import get_or_fetch_member
 from bot.utils.messages import send_denial
 from bot.utils.scheduling import Scheduler
-from bot.utils.time import TimestampFormats, discord_timestamp
 
 log = get_logger(__name__)
 
@@ -310,7 +309,8 @@ class Reminders(Cog):
             }
         )
 
-        mention_string = f"Your reminder will arrive on {discord_timestamp(expiration, TimestampFormats.DAY_TIME)}"
+        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)"
@@ -348,7 +348,7 @@ class Reminders(Cog):
         for content, remind_at, id_, mentions in reminders:
             # Parse and humanize the time, make it pretty :D
             remind_datetime = isoparse(remind_at)
-            time = discord_timestamp(remind_datetime, TimestampFormats.RELATIVE)
+            expiry = time.discord_timestamp(remind_datetime, time.TimestampFormats.RELATIVE)
 
             mentions = ", ".join([
                 # Both Role and User objects have the `name` attribute
@@ -357,7 +357,7 @@ class Reminders(Cog):
             mention_string = f"\n**Mentions:** {mentions}" if mentions else ""
 
             text = textwrap.dedent(f"""
-            **Reminder #{id_}:** *expires {time}* (ID: {id_}){mention_string}
+            **Reminder #{id_}:** *expires {expiry}* (ID: {id_}){mention_string}
             {content}
             """).strip()
 
diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index f76eea516..00fa7a388 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -13,8 +13,7 @@ from bot.converters import Snowflake
 from bot.decorators import in_whitelist
 from bot.log import get_logger
 from bot.pagination import LinePaginator
-from bot.utils import messages
-from bot.utils.time import time_since
+from bot.utils import messages, time
 
 log = get_logger(__name__)
 
@@ -173,7 +172,7 @@ class Utils(Cog):
         lines = []
         for snowflake in snowflakes:
             created_at = snowflake_time(snowflake)
-            lines.append(f"**{snowflake}**\nCreated at {created_at} ({time_since(created_at)}).")
+            lines.append(f"**{snowflake}**\nCreated at {created_at} ({time.time_since(created_at)}).")
 
         await LinePaginator.paginate(
             lines,
-- 
cgit v1.2.3


From 0bfdc16fc74be8ead1e6b8784757b9202293b745 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 16:32:23 -0700
Subject: Time: rename time_since to format_relative

While the function is basically just a wrapper for discord_timestamp
now, it is very common to use the relative format. It's cumbersome
to import the format enum and pass it to discord_timestamp calls, so
keeping this function around will be nice.
---
 bot/exts/recruitment/talentpool/_review.py |  4 ++--
 bot/exts/utils/utils.py                    |  2 +-
 bot/utils/time.py                          | 15 ++++++++++-----
 3 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/bot/exts/recruitment/talentpool/_review.py b/bot/exts/recruitment/talentpool/_review.py
index bbffbe6e3..474f669c6 100644
--- a/bot/exts/recruitment/talentpool/_review.py
+++ b/bot/exts/recruitment/talentpool/_review.py
@@ -273,7 +273,7 @@ class Reviewer:
                 last_channel = user_activity["top_channel_activity"][-1]
                 channels += f", and {last_channel[1]} in {last_channel[0]}"
 
-        joined_at_formatted = time.time_since(member.joined_at)
+        joined_at_formatted = time.format_relative(member.joined_at)
         review = (
             f"{member.name} joined the server **{joined_at_formatted}**"
             f" and has **{messages} messages**{channels}."
@@ -365,7 +365,7 @@ class Reviewer:
 
         nomination_times = f"{num_entries} times" if num_entries > 1 else "once"
         rejection_times = f"{len(history)} times" if len(history) > 1 else "once"
-        end_time = time.time_since(isoparse(history[0]['ended_at']))
+        end_time = time.format_relative(isoparse(history[0]['ended_at']))
 
         review = (
             f"They were nominated **{nomination_times}** before"
diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index 00fa7a388..2a074788e 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -172,7 +172,7 @@ class Utils(Cog):
         lines = []
         for snowflake in snowflakes:
             created_at = snowflake_time(snowflake)
-            lines.append(f"**{snowflake}**\nCreated at {created_at} ({time.time_since(created_at)}).")
+            lines.append(f"**{snowflake}**\nCreated at {created_at} ({time.format_relative(created_at)}).")
 
         await LinePaginator.paginate(
             lines,
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 545e50859..e6dcdee15 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -125,7 +125,7 @@ def humanize_delta(delta: relativedelta, precision: str = "seconds", max_units:
 def get_time_delta(time_string: str) -> str:
     """Returns the time in human-readable time delta format."""
     date_time = dateutil.parser.isoparse(time_string)
-    time_delta = time_since(date_time)
+    time_delta = format_relative(date_time)
 
     return time_delta
 
@@ -161,9 +161,14 @@ def relativedelta_to_timedelta(delta: relativedelta) -> datetime.timedelta:
     return utcnow + delta - utcnow
 
 
-def time_since(past_datetime: datetime.datetime) -> str:
-    """Takes a datetime and returns a discord timestamp that describes how long ago that datetime was."""
-    return discord_timestamp(past_datetime, TimestampFormats.RELATIVE)
+def format_relative(timestamp: ValidTimestamp) -> str:
+    """
+    Format `timestamp` as a relative Discord timestamp.
+
+    A relative timestamp describes how much time has elapsed since `timestamp` or how much time
+    remains until `timestamp` is reached. See `time.discord_timestamp`.
+    """
+    return discord_timestamp(timestamp, TimestampFormats.RELATIVE)
 
 
 def format_infraction(timestamp: str) -> str:
@@ -211,7 +216,7 @@ def until_expiration(
     Get the remaining time until infraction's expiration, in a discord timestamp.
 
     Returns a human-readable version of the remaining duration between arrow.utcnow() and an expiry.
-    Similar to time_since, except that this function doesn't error on a null input
+    Similar to format_relative, except that this function doesn't error on a null input
     and return null if the expiry is in the paste
     """
     if not expiry:
-- 
cgit v1.2.3


From ad1fcfbdab5be55f16ab157bcf86927c7996ed07 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 16:32:44 -0700
Subject: Time: replace discord_timestamp calls with format_relative

Use the latter where the former was being called with the relative
format type.
---
 bot/exts/info/information.py  | 6 +++---
 bot/exts/moderation/defcon.py | 2 +-
 bot/exts/utils/reminders.py   | 2 +-
 bot/utils/time.py             | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index a83ce4d53..29a00ec5d 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -173,7 +173,7 @@ class Information(Cog):
         """Returns an embed full of server information."""
         embed = Embed(colour=Colour.og_blurple(), title="Server Information")
 
-        created = time.discord_timestamp(ctx.guild.created_at, time.TimestampFormats.RELATIVE)
+        created = time.format_relative(ctx.guild.created_at)
         num_roles = len(ctx.guild.roles) - 1  # Exclude @everyone
 
         # Server Features are only useful in certain channels
@@ -249,7 +249,7 @@ class Information(Cog):
         """Creates an embed containing information on the `user`."""
         on_server = bool(await get_or_fetch_member(ctx.guild, user.id))
 
-        created = time.discord_timestamp(user.created_at, time.TimestampFormats.RELATIVE)
+        created = time.format_relative(user.created_at)
 
         name = str(user)
         if on_server and user.nick:
@@ -272,7 +272,7 @@ class Information(Cog):
 
         if on_server:
             if user.joined_at:
-                joined = time.discord_timestamp(user.joined_at, time.TimestampFormats.RELATIVE)
+                joined = time.format_relative(user.joined_at)
             else:
                 joined = "Unable to get join date"
 
diff --git a/bot/exts/moderation/defcon.py b/bot/exts/moderation/defcon.py
index 048e0f990..263e8136e 100644
--- a/bot/exts/moderation/defcon.py
+++ b/bot/exts/moderation/defcon.py
@@ -148,7 +148,7 @@ class Defcon(Cog):
     @has_any_role(*MODERATION_ROLES)
     async def status(self, ctx: Context) -> None:
         """Check the current status of DEFCON mode."""
-        expiry = time.discord_timestamp(self.expiry, time.TimestampFormats.RELATIVE) if self.expiry else "-"
+        expiry = time.format_relative(self.expiry) if self.expiry else "-"
         embed = Embed(
             colour=Colour.og_blurple(), title="DEFCON Status",
             description=f"""
diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
index dc7782727..bfa294809 100644
--- a/bot/exts/utils/reminders.py
+++ b/bot/exts/utils/reminders.py
@@ -348,7 +348,7 @@ class Reminders(Cog):
         for content, remind_at, id_, mentions in reminders:
             # Parse and humanize the time, make it pretty :D
             remind_datetime = isoparse(remind_at)
-            expiry = time.discord_timestamp(remind_datetime, time.TimestampFormats.RELATIVE)
+            expiry = time.format_relative(remind_datetime)
 
             mentions = ", ".join([
                 # Both Role and User objects have the `name` attribute
diff --git a/bot/utils/time.py b/bot/utils/time.py
index e6dcdee15..da56bcea8 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -228,4 +228,4 @@ def until_expiration(
     if since < now:
         return None
 
-    return discord_timestamp(since, TimestampFormats.RELATIVE)
+    return format_relative(since)
-- 
cgit v1.2.3


From 3ac1ef92b928c26985342a3f35934a1c7c08d2b4 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 16:35:41 -0700
Subject: Time: remove absolute param from format_infraction_with_duration

It's not used anywhere. Furthermore, a humanised duration with negative
values wouldn't make sense.
---
 bot/utils/time.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index da56bcea8..190adf885 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -180,16 +180,12 @@ def format_infraction_with_duration(
     date_to: Optional[str],
     date_from: Optional[datetime.datetime] = None,
     max_units: int = 2,
-    absolute: bool = True
 ) -> Optional[str]:
     """
     Return `date_to` formatted as a discord timestamp with the timestamp duration since `date_from`.
 
     `max_units` specifies the maximum number of units of time to include in the duration. For
     example, a value of 1 may include days but not hours.
-
-    If `absolute` is True, the absolute value of the duration delta is used. This prevents negative
-    values in the case that `date_to` is in the past relative to `date_from`.
     """
     if not date_to:
         return None
@@ -199,10 +195,7 @@ def format_infraction_with_duration(
     date_from = date_from or datetime.datetime.now(datetime.timezone.utc)
     date_to = dateutil.parser.isoparse(date_to).replace(microsecond=0)
 
-    delta = relativedelta(date_to, date_from)
-    if absolute:
-        delta = abs(delta)
-
+    delta = abs(relativedelta(date_to, date_from))
     duration = humanize_delta(delta, max_units=max_units)
     duration_formatted = f" ({duration})" if duration else ""
 
-- 
cgit v1.2.3


From 6ceb2c09114233f6db00e11ea85891adcdcf7f4f Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 17:19:24 -0700
Subject: Time: remove broken enum type check in discord_timestamp

First, the `args` attribute doesn't exist on enums. Even if it did, this
check only works if the argument given is an enum member (of any enum).
Such occurrence seems too rare to warrant an explicit check.
---
 bot/utils/time.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index 190adf885..ddcf5bac2 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -62,9 +62,6 @@ def _stringify_time_unit(value: int, unit: str) -> str:
 
 def discord_timestamp(timestamp: ValidTimestamp, format: TimestampFormats = TimestampFormats.DATE_TIME) -> str:
     """Create and format a Discord flavored markdown timestamp."""
-    if format not in TimestampFormats:
-        raise ValueError(f"Format can only be one of {', '.join(TimestampFormats.args)}, not {format}.")
-
     # Convert each possible timestamp class to an integer.
     if isinstance(timestamp, datetime.datetime):
         timestamp = (timestamp - arrow.get(0)).total_seconds()
-- 
cgit v1.2.3


From 24b28e264719e5bf40f565d553f7e9e57041b0a2 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 17:20:31 -0700
Subject: Time: remove timedelta and relativedelta support from
 discord_timestamp

When a delta is given, it is unknown what it's relative to. The function
has to assume it's relative to the POSIX Epoch. However, using a delta
for this would be quite odd, and would more likely be a mistake if
anything.

relativedelta support was broken anyway since it wasn't using the
total seconds represented by the delta.
---
 bot/utils/time.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index ddcf5bac2..60720031a 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -20,7 +20,7 @@ _DURATION_REGEX = re.compile(
 )
 
 
-ValidTimestamp = Union[int, datetime.datetime, datetime.date, datetime.timedelta, relativedelta]
+ValidTimestamp = Union[int, datetime.datetime, datetime.date]
 
 
 class TimestampFormats(Enum):
@@ -67,10 +67,6 @@ def discord_timestamp(timestamp: ValidTimestamp, format: TimestampFormats = Time
         timestamp = (timestamp - arrow.get(0)).total_seconds()
     elif isinstance(timestamp, datetime.date):
         timestamp = (timestamp - arrow.get(0)).total_seconds()
-    elif isinstance(timestamp, datetime.timedelta):
-        timestamp = timestamp.total_seconds()
-    elif isinstance(timestamp, relativedelta):
-        timestamp = timestamp.seconds
 
     return f"<t:{int(timestamp)}:{format.value}>"
 
-- 
cgit v1.2.3


From 93742d718dcb4aee72ef5d20ca570b6200f07d2d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 19:14:08 -0700
Subject: Time: rename format_infraction_with_duration

It's not necessarily tied to infractions anymore.
---
 bot/exts/moderation/infraction/_scheduler.py |  4 ++--
 bot/exts/moderation/infraction/management.py |  2 +-
 bot/exts/moderation/stream.py                |  2 +-
 bot/utils/time.py                            | 18 +++++++++---------
 tests/bot/utils/test_time.py                 | 18 +++++++++---------
 5 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 57aa2d9b6..9d4d58e2e 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -136,7 +136,7 @@ class InfractionScheduler:
         infr_type = infraction["type"]
         icon = _utils.INFRACTION_ICONS[infr_type][0]
         reason = infraction["reason"]
-        expiry = time.format_infraction_with_duration(infraction["expires_at"])
+        expiry = time.format_with_duration(infraction["expires_at"])
         id_ = infraction['id']
 
         if user_reason is None:
@@ -387,7 +387,7 @@ class InfractionScheduler:
         log.info(f"Marking infraction #{id_} as inactive (expired).")
 
         expiry = dateutil.parser.isoparse(expiry) if expiry else None
-        created = time.format_infraction_with_duration(inserted_at, expiry)
+        created = time.format_with_duration(inserted_at, expiry)
 
         log_content = None
         log_text = {
diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index fb5af9eaa..dd994a2d2 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -150,7 +150,7 @@ class ModManagement(commands.Cog):
             confirm_messages.append("marked as permanent")
         elif duration is not None:
             request_data['expires_at'] = duration.isoformat()
-            expiry = time.format_infraction_with_duration(request_data['expires_at'])
+            expiry = time.format_with_duration(request_data['expires_at'])
             confirm_messages.append(f"set to expire on {expiry}")
         else:
             confirm_messages.append("expiry unchanged")
diff --git a/bot/exts/moderation/stream.py b/bot/exts/moderation/stream.py
index 5a7b12295..bc9d35714 100644
--- a/bot/exts/moderation/stream.py
+++ b/bot/exts/moderation/stream.py
@@ -133,7 +133,7 @@ class Stream(commands.Cog):
         await ctx.send(f"{Emojis.check_mark} {member.mention} can now stream until {time.discord_timestamp(duration)}.")
 
         # Convert here for nicer logging
-        revoke_time = time.format_infraction_with_duration(str(duration))
+        revoke_time = time.format_with_duration(str(duration))
         log.debug(f"Successfully gave {member} ({member.id}) permission to stream until {revoke_time}.")
 
     @commands.command(aliases=("pstream",))
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 60720031a..13dfc6fb7 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -169,26 +169,26 @@ def format_infraction(timestamp: str) -> str:
     return discord_timestamp(dateutil.parser.isoparse(timestamp))
 
 
-def format_infraction_with_duration(
-    date_to: Optional[str],
-    date_from: Optional[datetime.datetime] = None,
+def format_with_duration(
+    timestamp: Optional[str],
+    other_timestamp: Optional[datetime.datetime] = None,
     max_units: int = 2,
 ) -> Optional[str]:
     """
-    Return `date_to` formatted as a discord timestamp with the timestamp duration since `date_from`.
+    Return `timestamp` formatted as a discord timestamp with the timestamp duration since `other_timestamp`.
 
     `max_units` specifies the maximum number of units of time to include in the duration. For
     example, a value of 1 may include days but not hours.
     """
-    if not date_to:
+    if not timestamp:
         return None
 
-    date_to_formatted = format_infraction(date_to)
+    date_to_formatted = format_infraction(timestamp)
 
-    date_from = date_from or datetime.datetime.now(datetime.timezone.utc)
-    date_to = dateutil.parser.isoparse(date_to).replace(microsecond=0)
+    other_timestamp = other_timestamp or datetime.datetime.now(datetime.timezone.utc)
+    timestamp = dateutil.parser.isoparse(timestamp).replace(microsecond=0)
 
-    delta = abs(relativedelta(date_to, date_from))
+    delta = abs(relativedelta(timestamp, other_timestamp))
     duration = humanize_delta(delta, max_units=max_units)
     duration_formatted = f" ({duration})" if duration else ""
 
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 9c52fed27..02b5f8c17 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -47,8 +47,8 @@ class TimeTests(unittest.TestCase):
         """Testing format_infraction."""
         self.assertEqual(time.format_infraction('2019-12-12T00:01:00Z'), '<t:1576108860:f>')
 
-    def test_format_infraction_with_duration_none_expiry(self):
-        """format_infraction_with_duration should work for None expiry."""
+    def test_format_with_duration_none_expiry(self):
+        """format_with_duration should work for None expiry."""
         test_cases = (
             (None, None, None, None),
 
@@ -60,10 +60,10 @@ class TimeTests(unittest.TestCase):
 
         for expiry, date_from, max_units, expected in test_cases:
             with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
-                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+                self.assertEqual(time.format_with_duration(expiry, date_from, max_units), expected)
 
-    def test_format_infraction_with_duration_custom_units(self):
-        """format_infraction_with_duration should work for custom max_units."""
+    def test_format_with_duration_custom_units(self):
+        """format_with_duration should work for custom max_units."""
         test_cases = (
             ('3000-12-12T00:01:00Z', datetime(3000, 12, 11, 12, 5, 5, tzinfo=timezone.utc), 6,
              '<t:32533488060:f> (11 hours, 55 minutes and 55 seconds)'),
@@ -73,10 +73,10 @@ class TimeTests(unittest.TestCase):
 
         for expiry, date_from, max_units, expected in test_cases:
             with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
-                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+                self.assertEqual(time.format_with_duration(expiry, date_from, max_units), expected)
 
-    def test_format_infraction_with_duration_normal_usage(self):
-        """format_infraction_with_duration should work for normal usage, across various durations."""
+    def test_format_with_duration_normal_usage(self):
+        """format_with_duration should work for normal usage, across various durations."""
         utc = timezone.utc
         test_cases = (
             ('2019-12-12T00:01:00Z', datetime(2019, 12, 11, 12, 0, 5, tzinfo=utc), 2,
@@ -98,7 +98,7 @@ class TimeTests(unittest.TestCase):
 
         for expiry, date_from, max_units, expected in test_cases:
             with self.subTest(expiry=expiry, date_from=date_from, max_units=max_units, expected=expected):
-                self.assertEqual(time.format_infraction_with_duration(expiry, date_from, max_units), expected)
+                self.assertEqual(time.format_with_duration(expiry, date_from, max_units), expected)
 
     def test_until_expiration_with_duration_none_expiry(self):
         """until_expiration should work for None expiry."""
-- 
cgit v1.2.3


From ea7fc62ddc8d08b6acdb00ac2d9a024fee8ad634 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 19:26:26 -0700
Subject: Time: support more timestamp formats as arguments

Remove the burden of conversion from the caller to clean up and simplify
the call sites. Handle timestamp conversions internally with arrow.get.

Remove format_infraction and get_time_delta because they're now
obsolete. Replace the former with discord_timestamp and the latter with
format_relative.
---
 bot/exts/moderation/infraction/_scheduler.py       |  7 +-
 bot/exts/moderation/infraction/management.py       |  4 +-
 bot/exts/moderation/infraction/superstarify.py     |  4 +-
 bot/exts/moderation/stream.py                      |  2 +-
 bot/exts/moderation/watchchannels/_watchchannel.py |  4 +-
 bot/exts/recruitment/talentpool/_cog.py            |  8 +-
 bot/exts/recruitment/talentpool/_review.py         |  4 +-
 bot/exts/utils/reminders.py                        |  5 +-
 bot/utils/time.py                                  | 94 +++++++++++-----------
 tests/bot/utils/test_time.py                       |  4 -
 10 files changed, 63 insertions(+), 73 deletions(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 9d4d58e2e..47b639421 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -381,20 +381,15 @@ class InfractionScheduler:
         actor = infraction["actor"]
         type_ = infraction["type"]
         id_ = infraction["id"]
-        inserted_at = infraction["inserted_at"]
-        expiry = infraction["expires_at"]
 
         log.info(f"Marking infraction #{id_} as inactive (expired).")
 
-        expiry = dateutil.parser.isoparse(expiry) if expiry else None
-        created = time.format_with_duration(inserted_at, expiry)
-
         log_content = None
         log_text = {
             "Member": f"<@{user_id}>",
             "Actor": f"<@{actor}>",
             "Reason": infraction["reason"],
-            "Created": created,
+            "Created": time.format_with_duration(infraction["inserted_at"], infraction["expires_at"]),
         }
 
         try:
diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index dd994a2d2..23c6e8b92 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -150,7 +150,7 @@ class ModManagement(commands.Cog):
             confirm_messages.append("marked as permanent")
         elif duration is not None:
             request_data['expires_at'] = duration.isoformat()
-            expiry = time.format_with_duration(request_data['expires_at'])
+            expiry = time.format_with_duration(duration)
             confirm_messages.append(f"set to expire on {expiry}")
         else:
             confirm_messages.append("expiry unchanged")
@@ -351,7 +351,7 @@ class ModManagement(commands.Cog):
         active = infraction["active"]
         user = infraction["user"]
         expires_at = infraction["expires_at"]
-        created = time.format_infraction(infraction["inserted_at"])
+        created = time.discord_timestamp(infraction["inserted_at"])
         dm_sent = infraction["dm_sent"]
 
         # Format the user string.
diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 2e272dbb0..a037ca1be 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -73,7 +73,7 @@ class Superstarify(InfractionScheduler, Cog):
         notified = await _utils.notify_infraction(
             user=after,
             infr_type="Superstarify",
-            expires_at=time.format_infraction(infraction["expires_at"]),
+            expires_at=time.discord_timestamp(infraction["expires_at"]),
             reason=(
                 "You have tried to change your nickname on the **Python Discord** server "
                 f"from **{before.display_name}** to **{after.display_name}**, but as you "
@@ -150,7 +150,7 @@ class Superstarify(InfractionScheduler, Cog):
         id_ = infraction["id"]
 
         forced_nick = self.get_nick(id_, member.id)
-        expiry_str = time.format_infraction(infraction["expires_at"])
+        expiry_str = time.discord_timestamp(infraction["expires_at"])
 
         # Apply the infraction
         async def action() -> None:
diff --git a/bot/exts/moderation/stream.py b/bot/exts/moderation/stream.py
index bc9d35714..4dccc8a7e 100644
--- a/bot/exts/moderation/stream.py
+++ b/bot/exts/moderation/stream.py
@@ -133,7 +133,7 @@ class Stream(commands.Cog):
         await ctx.send(f"{Emojis.check_mark} {member.mention} can now stream until {time.discord_timestamp(duration)}.")
 
         # Convert here for nicer logging
-        revoke_time = time.format_with_duration(str(duration))
+        revoke_time = time.format_with_duration(duration)
         log.debug(f"Successfully gave {member} ({member.id}) permission to stream until {revoke_time}.")
 
     @commands.command(aliases=("pstream",))
diff --git a/bot/exts/moderation/watchchannels/_watchchannel.py b/bot/exts/moderation/watchchannels/_watchchannel.py
index 106483527..ee9b6ba45 100644
--- a/bot/exts/moderation/watchchannels/_watchchannel.py
+++ b/bot/exts/moderation/watchchannels/_watchchannel.py
@@ -285,7 +285,7 @@ class WatchChannel(metaclass=CogABCMeta):
         actor = actor.display_name if actor else self.watched_users[user_id]['actor']
 
         inserted_at = self.watched_users[user_id]['inserted_at']
-        time_delta = time.get_time_delta(inserted_at)
+        time_delta = time.format_relative(inserted_at)
 
         reason = self.watched_users[user_id]['reason']
 
@@ -359,7 +359,7 @@ class WatchChannel(metaclass=CogABCMeta):
             if member:
                 line += f" ({member.name}#{member.discriminator})"
             inserted_at = user_data['inserted_at']
-            line += f", added {time.get_time_delta(inserted_at)}"
+            line += f", added {time.format_relative(inserted_at)}"
             if not member:  # Cross off users who left the server.
                 line = f"~~{line}~~"
             list_data["info"][user_id] = line
diff --git a/bot/exts/recruitment/talentpool/_cog.py b/bot/exts/recruitment/talentpool/_cog.py
index 80274eaea..bbc135454 100644
--- a/bot/exts/recruitment/talentpool/_cog.py
+++ b/bot/exts/recruitment/talentpool/_cog.py
@@ -180,7 +180,7 @@ class TalentPool(Cog, name="Talentpool"):
             if member:
                 line += f" ({member.name}#{member.discriminator})"
             inserted_at = user_data['inserted_at']
-            line += f", added {time.get_time_delta(inserted_at)}"
+            line += f", added {time.format_relative(inserted_at)}"
             if not member:  # Cross off users who left the server.
                 line = f"~~{line}~~"
             if user_data['reviewed']:
@@ -561,7 +561,7 @@ class TalentPool(Cog, name="Talentpool"):
             actor = await get_or_fetch_member(guild, actor_id)
 
             reason = site_entry["reason"] or "*None*"
-            created = time.format_infraction(site_entry["inserted_at"])
+            created = time.discord_timestamp(site_entry["inserted_at"])
             entries.append(
                 f"Actor: {actor.mention if actor else actor_id}\nCreated: {created}\nReason: {reason}"
             )
@@ -570,7 +570,7 @@ class TalentPool(Cog, name="Talentpool"):
 
         active = nomination_object["active"]
 
-        start_date = time.format_infraction(nomination_object["inserted_at"])
+        start_date = time.discord_timestamp(nomination_object["inserted_at"])
         if active:
             lines = textwrap.dedent(
                 f"""
@@ -584,7 +584,7 @@ class TalentPool(Cog, name="Talentpool"):
                 """
             )
         else:
-            end_date = time.format_infraction(nomination_object["ended_at"])
+            end_date = time.discord_timestamp(nomination_object["ended_at"])
             lines = textwrap.dedent(
                 f"""
                 ===============
diff --git a/bot/exts/recruitment/talentpool/_review.py b/bot/exts/recruitment/talentpool/_review.py
index 474f669c6..b4d177622 100644
--- a/bot/exts/recruitment/talentpool/_review.py
+++ b/bot/exts/recruitment/talentpool/_review.py
@@ -321,7 +321,7 @@ class Reviewer:
             infractions += ", with the last infraction issued "
 
         # Infractions were ordered by time since insertion descending.
-        infractions += time.get_time_delta(infraction_list[0]['inserted_at'])
+        infractions += time.format_relative(infraction_list[0]['inserted_at'])
 
         return f"They have {infractions}."
 
@@ -365,7 +365,7 @@ class Reviewer:
 
         nomination_times = f"{num_entries} times" if num_entries > 1 else "once"
         rejection_times = f"{len(history)} times" if len(history) > 1 else "once"
-        end_time = time.format_relative(isoparse(history[0]['ended_at']))
+        end_time = time.format_relative(history[0]['ended_at'])
 
         review = (
             f"They were nominated **{nomination_times}** before"
diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
index bfa294809..289d00356 100644
--- a/bot/exts/utils/reminders.py
+++ b/bot/exts/utils/reminders.py
@@ -168,7 +168,7 @@ class Reminders(Cog):
         self.schedule_reminder(reminder)
 
     @lock_arg(LOCK_NAMESPACE, "reminder", itemgetter("id"), raise_error=True)
-    async def send_reminder(self, reminder: dict, expected_time: datetime = None) -> None:
+    async def send_reminder(self, reminder: dict, expected_time: t.Optional[time.Timestamp] = None) -> None:
         """Send the reminder."""
         is_valid, user, channel = self.ensure_valid_reminder(reminder)
         if not is_valid:
@@ -347,8 +347,7 @@ class Reminders(Cog):
 
         for content, remind_at, id_, mentions in reminders:
             # Parse and humanize the time, make it pretty :D
-            remind_datetime = isoparse(remind_at)
-            expiry = time.format_relative(remind_datetime)
+            expiry = time.format_relative(remind_at)
 
             mentions = ", ".join([
                 # Both Role and User objects have the `name` attribute
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 13dfc6fb7..e927a5e63 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -1,10 +1,10 @@
 import datetime
 import re
 from enum import Enum
+from time import struct_time
 from typing import Optional, Union
 
 import arrow
-import dateutil.parser
 from dateutil.relativedelta import relativedelta
 
 DISCORD_TIMESTAMP_REGEX = re.compile(r"<t:(\d+):f>")
@@ -19,8 +19,18 @@ _DURATION_REGEX = re.compile(
     r"((?P<seconds>\d+?) ?(seconds|second|S|s))?"
 )
 
-
-ValidTimestamp = Union[int, datetime.datetime, datetime.date]
+# All supported types for the single-argument overload of arrow.get(). tzinfo is excluded because
+# it's too implicit of a way for the caller to specify that they want the current time.
+Timestamp = Union[
+    arrow.Arrow,
+    datetime.datetime,
+    datetime.date,
+    struct_time,
+    int,  # POSIX timestamp
+    float,  # POSIX timestamp
+    str,  # ISO 8601-formatted string
+    tuple[int, int, int],  # ISO calendar tuple
+]
 
 
 class TimestampFormats(Enum):
@@ -60,15 +70,14 @@ def _stringify_time_unit(value: int, unit: str) -> str:
         return f"{value} {unit}"
 
 
-def discord_timestamp(timestamp: ValidTimestamp, format: TimestampFormats = TimestampFormats.DATE_TIME) -> str:
-    """Create and format a Discord flavored markdown timestamp."""
-    # Convert each possible timestamp class to an integer.
-    if isinstance(timestamp, datetime.datetime):
-        timestamp = (timestamp - arrow.get(0)).total_seconds()
-    elif isinstance(timestamp, datetime.date):
-        timestamp = (timestamp - arrow.get(0)).total_seconds()
+def discord_timestamp(timestamp: Timestamp, format: TimestampFormats = TimestampFormats.DATE_TIME) -> str:
+    """
+    Format a timestamp as a Discord-flavored Markdown timestamp.
 
-    return f"<t:{int(timestamp)}:{format.value}>"
+    `timestamp` can be any type supported by the single-arg `arrow.get()`, except for a `tzinfo`.
+    """
+    timestamp = int(arrow.get(timestamp).timestamp())
+    return f"<t:{timestamp}:{format.value}>"
 
 
 def humanize_delta(delta: relativedelta, precision: str = "seconds", max_units: int = 6) -> str:
@@ -115,14 +124,6 @@ def humanize_delta(delta: relativedelta, precision: str = "seconds", max_units:
     return humanized
 
 
-def get_time_delta(time_string: str) -> str:
-    """Returns the time in human-readable time delta format."""
-    date_time = dateutil.parser.isoparse(time_string)
-    time_delta = format_relative(date_time)
-
-    return time_delta
-
-
 def parse_duration_string(duration: str) -> Optional[relativedelta]:
     """
     Converts a `duration` string to a relativedelta object.
@@ -154,64 +155,63 @@ def relativedelta_to_timedelta(delta: relativedelta) -> datetime.timedelta:
     return utcnow + delta - utcnow
 
 
-def format_relative(timestamp: ValidTimestamp) -> str:
+def format_relative(timestamp: Timestamp) -> str:
     """
     Format `timestamp` as a relative Discord timestamp.
 
     A relative timestamp describes how much time has elapsed since `timestamp` or how much time
-    remains until `timestamp` is reached. See `time.discord_timestamp`.
+    remains until `timestamp` is reached.
+
+    `timestamp` can be any type supported by the single-arg `arrow.get()`, except for a `tzinfo`.
     """
     return discord_timestamp(timestamp, TimestampFormats.RELATIVE)
 
 
-def format_infraction(timestamp: str) -> str:
-    """Format an infraction timestamp to a discord timestamp."""
-    return discord_timestamp(dateutil.parser.isoparse(timestamp))
-
-
 def format_with_duration(
-    timestamp: Optional[str],
-    other_timestamp: Optional[datetime.datetime] = None,
+    timestamp: Optional[Timestamp],
+    other_timestamp: Optional[Timestamp] = None,
     max_units: int = 2,
 ) -> Optional[str]:
     """
     Return `timestamp` formatted as a discord timestamp with the timestamp duration since `other_timestamp`.
 
+    `timestamp` and `other_timestamp` can be any type supported by the single-arg `arrow.get()`,
+    except for a `tzinfo`. Use the current time if `other_timestamp` is falsy or unspecified.
+
     `max_units` specifies the maximum number of units of time to include in the duration. For
     example, a value of 1 may include days but not hours.
+
+    Return None if `timestamp` is falsy.
     """
     if not timestamp:
         return None
 
-    date_to_formatted = format_infraction(timestamp)
-
-    other_timestamp = other_timestamp or datetime.datetime.now(datetime.timezone.utc)
-    timestamp = dateutil.parser.isoparse(timestamp).replace(microsecond=0)
+    timestamp = arrow.get(timestamp)
+    if not other_timestamp:
+        other_timestamp = arrow.utcnow()
+    else:
+        other_timestamp = arrow.get(other_timestamp)
 
-    delta = abs(relativedelta(timestamp, other_timestamp))
+    formatted_timestamp = discord_timestamp(timestamp)
+    delta = abs(relativedelta(timestamp.datetime, other_timestamp.datetime))
     duration = humanize_delta(delta, max_units=max_units)
-    duration_formatted = f" ({duration})" if duration else ""
 
-    return f"{date_to_formatted}{duration_formatted}"
+    return f"{formatted_timestamp} ({duration})"
 
 
-def until_expiration(
-    expiry: Optional[str]
-) -> Optional[str]:
+def until_expiration(expiry: Optional[Timestamp]) -> Optional[str]:
     """
-    Get the remaining time until infraction's expiration, in a discord timestamp.
+    Get the remaining time until an infraction's expiration as a Discord timestamp.
 
-    Returns a human-readable version of the remaining duration between arrow.utcnow() and an expiry.
-    Similar to format_relative, except that this function doesn't error on a null input
-    and return null if the expiry is in the paste
+    `expiry` can be any type supported by the single-arg `arrow.get()`, except for a `tzinfo`.
+
+    Return None if `expiry` is falsy or is in the past.
     """
     if not expiry:
         return None
 
-    now = arrow.utcnow()
-    since = dateutil.parser.isoparse(expiry).replace(microsecond=0)
-
-    if since < now:
+    expiry = arrow.get(expiry)
+    if expiry < arrow.utcnow():
         return None
 
-    return format_relative(since)
+    return format_relative(expiry)
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 02b5f8c17..027e2052e 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -43,10 +43,6 @@ class TimeTests(unittest.TestCase):
                 time.humanize_delta(relativedelta(days=2, hours=2), 'hours', max_units)
             self.assertEqual(str(error.exception), 'max_units must be positive')
 
-    def test_format_infraction(self):
-        """Testing format_infraction."""
-        self.assertEqual(time.format_infraction('2019-12-12T00:01:00Z'), '<t:1576108860:f>')
-
     def test_format_with_duration_none_expiry(self):
         """format_with_duration should work for None expiry."""
         test_cases = (
-- 
cgit v1.2.3


From 75fabfc0f1a9d95a1167dd6f3d94b741768b72e8 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 5 Aug 2021 21:26:36 -0700
Subject: Time: remove DISCORD_TIMESTAMP_REGEX

There's a saner way to parse the timestamp that relied on this regex.
---
 bot/exts/moderation/infraction/management.py | 15 ++++++---------
 bot/utils/time.py                            |  2 --
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 23c6e8b92..fa1ebdadc 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -1,8 +1,7 @@
 import textwrap
 import typing as t
-from datetime import datetime, timezone
 
-import dateutil.parser
+import arrow
 import discord
 from dateutil.relativedelta import relativedelta
 from discord.ext import commands
@@ -351,7 +350,8 @@ class ModManagement(commands.Cog):
         active = infraction["active"]
         user = infraction["user"]
         expires_at = infraction["expires_at"]
-        created = time.discord_timestamp(infraction["inserted_at"])
+        inserted_at = infraction["inserted_at"]
+        created = time.discord_timestamp(inserted_at)
         dm_sent = infraction["dm_sent"]
 
         # Format the user string.
@@ -371,12 +371,9 @@ class ModManagement(commands.Cog):
         if expires_at is None:
             duration = "*Permanent*"
         else:
-            date_from = datetime.fromtimestamp(
-                float(time.DISCORD_TIMESTAMP_REGEX.match(created).group(1)),
-                timezone.utc
-            )
-            date_to = dateutil.parser.isoparse(expires_at)
-            duration = time.humanize_delta(relativedelta(date_to, date_from))
+            start = arrow.get(inserted_at).datetime
+            end = arrow.get(expires_at).datetime
+            duration = time.humanize_delta(relativedelta(start, end))
 
         # Format `dm_sent`
         if dm_sent is None:
diff --git a/bot/utils/time.py b/bot/utils/time.py
index e927a5e63..21d26db7d 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -7,8 +7,6 @@ from typing import Optional, Union
 import arrow
 from dateutil.relativedelta import relativedelta
 
-DISCORD_TIMESTAMP_REGEX = re.compile(r"<t:(\d+):f>")
-
 _DURATION_REGEX = re.compile(
     r"((?P<years>\d+?) ?(years|year|Y|y) ?)?"
     r"((?P<months>\d+?) ?(months|month|m) ?)?"
-- 
cgit v1.2.3


From 2004477e12c72e4739ea1b1f192fb2c12eac69d0 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 6 Aug 2021 14:20:52 -0700
Subject: Time: add overload to pass 2 timestamps to humanize_delta

Remove the need for the caller to create a `relativedelta` from 2
timestamps before calling `humanize_delta`. This is especially
convenient for cases where the original inputs aren't `datetime`s
since `relativedelta` only accepts those.
---
 bot/exts/moderation/defcon.py                |   4 +-
 bot/exts/moderation/infraction/management.py |   6 +-
 bot/exts/moderation/modlog.py                |   2 +-
 bot/utils/time.py                            | 110 ++++++++++++++++++++++-----
 tests/bot/utils/test_time.py                 |  13 ++--
 5 files changed, 105 insertions(+), 30 deletions(-)

diff --git a/bot/exts/moderation/defcon.py b/bot/exts/moderation/defcon.py
index 263e8136e..178be734d 100644
--- a/bot/exts/moderation/defcon.py
+++ b/bot/exts/moderation/defcon.py
@@ -254,8 +254,8 @@ class Defcon(Cog):
 
         expiry_message = ""
         if expiry:
-            activity_duration = relativedelta(expiry, arrow.utcnow().datetime)
-            expiry_message = f" for the next {time.humanize_delta(activity_duration, max_units=2)}"
+            formatted_expiry = time.humanize_delta(expiry, max_units=2)
+            expiry_message = f" for the next {formatted_expiry}"
 
         if self.threshold:
             channel_message = (
diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index fa1ebdadc..0dfd2d759 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -1,9 +1,7 @@
 import textwrap
 import typing as t
 
-import arrow
 import discord
-from dateutil.relativedelta import relativedelta
 from discord.ext import commands
 from discord.ext.commands import Context
 from discord.utils import escape_markdown
@@ -371,9 +369,7 @@ class ModManagement(commands.Cog):
         if expires_at is None:
             duration = "*Permanent*"
         else:
-            start = arrow.get(inserted_at).datetime
-            end = arrow.get(expires_at).datetime
-            duration = time.humanize_delta(relativedelta(start, end))
+            duration = time.humanize_delta(inserted_at, expires_at)
 
         # Format `dm_sent`
         if dm_sent is None:
diff --git a/bot/exts/moderation/modlog.py b/bot/exts/moderation/modlog.py
index d5e209d81..2c01a4a21 100644
--- a/bot/exts/moderation/modlog.py
+++ b/bot/exts/moderation/modlog.py
@@ -713,7 +713,7 @@ class ModLog(Cog, name="ModLog"):
             # datetime as the baseline and create a human-readable delta between this edit event
             # and the last time the message was edited
             timestamp = msg_before.edited_at
-            delta = time.humanize_delta(relativedelta(msg_after.edited_at, msg_before.edited_at))
+            delta = time.humanize_delta(msg_after.edited_at, msg_before.edited_at)
             footer = f"Last edited {delta} ago"
         else:
             # Message was not previously edited, use the created_at datetime as the baseline, no
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 21d26db7d..7e314a870 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -2,7 +2,7 @@ import datetime
 import re
 from enum import Enum
 from time import struct_time
-from typing import Optional, Union
+from typing import Optional, Union, overload
 
 import arrow
 from dateutil.relativedelta import relativedelta
@@ -78,15 +78,99 @@ def discord_timestamp(timestamp: Timestamp, format: TimestampFormats = Timestamp
     return f"<t:{timestamp}:{format.value}>"
 
 
-def humanize_delta(delta: relativedelta, precision: str = "seconds", max_units: int = 6) -> str:
+@overload
+def humanize_delta(
+    arg1: Union[relativedelta, Timestamp],
+    /,
+    *,
+    precision: str = "seconds",
+    max_units: int = 6,
+    absolute: bool = True,
+) -> str:
+    ...
+
+
+@overload
+def humanize_delta(
+    end: Timestamp,
+    start: Timestamp,
+    /,
+    *,
+    precision: str = "seconds",
+    max_units: int = 6,
+    absolute: bool = True,
+) -> str:
+    ...
+
+
+def humanize_delta(
+    *args,
+    precision: str = "seconds",
+    max_units: int = 6,
+    absolute: bool = True,
+) -> str:
     """
-    Returns a human-readable version of the relativedelta.
+    Return a human-readable version of a time duration.
 
-    precision specifies the smallest unit of time to include (e.g. "seconds", "minutes").
-    max_units specifies the maximum number of units of time to include (e.g. 1 may include days but not hours).
+    `precision` is the smallest unit of time to include (e.g. "seconds", "minutes").
+
+    `max_units` is the maximum number of units of time to include.
+    Count units from largest to smallest (e.g. count days before months).
+
+    Use the absolute value of the duration if `absolute` is True.
+
+    Usage:
+
+    **One** `relativedelta` object, to humanize the duration represented by it:
+
+    >>> humanize_delta(relativedelta(years=12, months=6))
+    '12 years and 6 months'
+
+    Note that `leapdays` and absolute info (singular names) will be ignored during humanization.
+
+    **One** timestamp of a type supported by the single-arg `arrow.get()`, except for `tzinfo`,
+    to humanize the duration between it and the current time:
+
+    >>> humanize_delta('2021-08-06T12:43:01Z', absolute=True)  # now = 2021-08-06T12:33:33Z
+    '9 minutes and 28 seconds'
+
+    >>> humanize_delta('2021-08-06T12:43:01Z', absolute=False)  # now = 2021-08-06T12:33:33Z
+    '-9 minutes and -28 seconds'
+
+    **Two** timestamps, each of a type supported by the single-arg `arrow.get()`, except for
+    `tzinfo`, to humanize the duration between them:
+
+    >>> humanize_delta(datetime.datetime(2020, 1, 1), '2021-01-01T12:00:00Z', absolute=False)
+    '1 year and 12 hours'
+
+    >>> humanize_delta('2021-01-01T12:00:00Z', datetime.datetime(2020, 1, 1), absolute=False)
+    '-1 years and -12 hours'
+
+    Note that order of the arguments can result in a different output even if `absolute` is True:
+
+    >>> x = datetime.datetime(3000, 11, 1)
+    >>> y = datetime.datetime(3000, 9, 2)
+    >>> humanize_delta(y, x, absolute=True), humanize_delta(x, y, absolute=True)
+    ('1 month and 30 days', '1 month and 29 days')
+
+    This is due to the nature of `relativedelta`; it does not represent a fixed period of time.
+    Instead, it's relative to the `datetime` to which it's added to get the other `datetime`.
+    In the example, the difference arises because all months don't have the same number of days.
     """
+    if len(args) == 1 and isinstance(args[0], relativedelta):
+        delta = args[0]
+    elif 1 <= len(args) <= 2:
+        end = arrow.get(args[0])
+        start = arrow.get(args[1]) if len(args) == 2 else arrow.utcnow()
+
+        delta = relativedelta(end.datetime, start.datetime)
+        if absolute:
+            delta = abs(delta)
+    else:
+        raise ValueError(f"Received {len(args)} positional arguments, but expected 1 or 2.")
+
     if max_units <= 0:
-        raise ValueError("max_units must be positive")
+        raise ValueError("max_units must be positive.")
 
     units = (
         ("years", delta.years),
@@ -174,25 +258,17 @@ def format_with_duration(
     Return `timestamp` formatted as a discord timestamp with the timestamp duration since `other_timestamp`.
 
     `timestamp` and `other_timestamp` can be any type supported by the single-arg `arrow.get()`,
-    except for a `tzinfo`. Use the current time if `other_timestamp` is falsy or unspecified.
+    except for a `tzinfo`. Use the current time if `other_timestamp` is None or unspecified.
 
-    `max_units` specifies the maximum number of units of time to include in the duration. For
-    example, a value of 1 may include days but not hours.
+    `max_units` is forwarded to `time.humanize_delta`. See its documentation for more information.
 
     Return None if `timestamp` is falsy.
     """
     if not timestamp:
         return None
 
-    timestamp = arrow.get(timestamp)
-    if not other_timestamp:
-        other_timestamp = arrow.utcnow()
-    else:
-        other_timestamp = arrow.get(other_timestamp)
-
     formatted_timestamp = discord_timestamp(timestamp)
-    delta = abs(relativedelta(timestamp.datetime, other_timestamp.datetime))
-    duration = humanize_delta(delta, max_units=max_units)
+    duration = humanize_delta(timestamp, other_timestamp, max_units=max_units)
 
     return f"{formatted_timestamp} ({duration})"
 
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 027e2052e..e235f9b70 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -13,13 +13,15 @@ class TimeTests(unittest.TestCase):
         """humanize_delta should be able to handle unknown units, and will not abort."""
         # Does not abort for unknown units, as the unit name is checked
         # against the attribute of the relativedelta instance.
-        self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'elephants', 2), '2 days and 2 hours')
+        actual = time.humanize_delta(relativedelta(days=2, hours=2), precision='elephants', max_units=2)
+        self.assertEqual(actual, '2 days and 2 hours')
 
     def test_humanize_delta_handle_high_units(self):
         """humanize_delta should be able to handle very high units."""
         # Very high maximum units, but it only ever iterates over
         # each value the relativedelta might have.
-        self.assertEqual(time.humanize_delta(relativedelta(days=2, hours=2), 'hours', 20), '2 days and 2 hours')
+        actual = time.humanize_delta(relativedelta(days=2, hours=2), precision='hours', max_units=20)
+        self.assertEqual(actual, '2 days and 2 hours')
 
     def test_humanize_delta_should_normal_usage(self):
         """Testing humanize delta."""
@@ -32,7 +34,8 @@ class TimeTests(unittest.TestCase):
 
         for delta, precision, max_units, expected in test_cases:
             with self.subTest(delta=delta, precision=precision, max_units=max_units, expected=expected):
-                self.assertEqual(time.humanize_delta(delta, precision, max_units), expected)
+                actual = time.humanize_delta(delta, precision=precision, max_units=max_units)
+                self.assertEqual(actual, expected)
 
     def test_humanize_delta_raises_for_invalid_max_units(self):
         """humanize_delta should raises ValueError('max_units must be positive') for invalid max_units."""
@@ -40,8 +43,8 @@ class TimeTests(unittest.TestCase):
 
         for max_units in test_cases:
             with self.subTest(max_units=max_units), self.assertRaises(ValueError) as error:
-                time.humanize_delta(relativedelta(days=2, hours=2), 'hours', max_units)
-            self.assertEqual(str(error.exception), 'max_units must be positive')
+                time.humanize_delta(relativedelta(days=2, hours=2), precision='hours', max_units=max_units)
+            self.assertEqual(str(error.exception), 'max_units must be positive.')
 
     def test_format_with_duration_none_expiry(self):
         """format_with_duration should work for None expiry."""
-- 
cgit v1.2.3


From 07b345eed59e775977da202602ed1c9568cca494 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 6 Aug 2021 15:25:17 -0700
Subject: Time: add overload to pass relativedelta kwargs to humanize_delta

---
 bot/exts/moderation/slowmode.py |  3 +--
 bot/utils/time.py               | 33 +++++++++++++++++++++++++++++++--
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/bot/exts/moderation/slowmode.py b/bot/exts/moderation/slowmode.py
index da04d1e98..b6a771441 100644
--- a/bot/exts/moderation/slowmode.py
+++ b/bot/exts/moderation/slowmode.py
@@ -39,8 +39,7 @@ class Slowmode(Cog):
         if channel is None:
             channel = ctx.channel
 
-        delay = relativedelta(seconds=channel.slowmode_delay)
-        humanized_delay = time.humanize_delta(delay)
+        humanized_delay = time.humanize_delta(seconds=channel.slowmode_delay)
 
         await ctx.send(f'The slowmode delay for {channel.mention} is {humanized_delay}.')
 
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 7e314a870..6fc43ef6a 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -103,11 +103,29 @@ def humanize_delta(
     ...
 
 
+@overload
+def humanize_delta(
+    *,
+    years: int = 0,
+    months: int = 0,
+    weeks: float = 0,
+    days: float = 0,
+    hours: float = 0,
+    minutes: float = 0,
+    seconds: float = 0,
+    precision: str = "seconds",
+    max_units: int = 6,
+    absolute: bool = True,
+) -> str:
+    ...
+
+
 def humanize_delta(
     *args,
     precision: str = "seconds",
     max_units: int = 6,
     absolute: bool = True,
+    **kwargs,
 ) -> str:
     """
     Return a human-readable version of a time duration.
@@ -121,6 +139,12 @@ def humanize_delta(
 
     Usage:
 
+    Keyword arguments specifying values for time units, to construct a `relativedelta` and humanize
+    the duration represented by it:
+
+    >>> humanize_delta(days=2, hours=16, seconds=23)
+    '2 days, 16 hours and 23 seconds'
+
     **One** `relativedelta` object, to humanize the duration represented by it:
 
     >>> humanize_delta(relativedelta(years=12, months=6))
@@ -157,9 +181,14 @@ def humanize_delta(
     Instead, it's relative to the `datetime` to which it's added to get the other `datetime`.
     In the example, the difference arises because all months don't have the same number of days.
     """
-    if len(args) == 1 and isinstance(args[0], relativedelta):
+    if args and kwargs:
+        raise ValueError("Unsupported combination of positional and keyword arguments.")
+
+    if len(args) == 0:
+        delta = relativedelta(**kwargs)
+    elif len(args) == 1 and isinstance(args[0], relativedelta):
         delta = args[0]
-    elif 1 <= len(args) <= 2:
+    elif len(args) <= 2:
         end = arrow.get(args[0])
         start = arrow.get(args[1]) if len(args) == 2 else arrow.utcnow()
 
-- 
cgit v1.2.3


From 40a2f71c41e5420b22e71a9d234bb83fd97729a5 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 6 Aug 2021 15:38:48 -0700
Subject: Time: use typing.Literal for precision param of humanize_delta

---
 bot/utils/time.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index 6fc43ef6a..8ba49a455 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -2,7 +2,7 @@ import datetime
 import re
 from enum import Enum
 from time import struct_time
-from typing import Optional, Union, overload
+from typing import Literal, Optional, Union, overload
 
 import arrow
 from dateutil.relativedelta import relativedelta
@@ -29,6 +29,7 @@ Timestamp = Union[
     str,  # ISO 8601-formatted string
     tuple[int, int, int],  # ISO calendar tuple
 ]
+_Precision = Literal["years", "months", "days", "hours", "minutes", "seconds"]
 
 
 class TimestampFormats(Enum):
@@ -83,7 +84,7 @@ def humanize_delta(
     arg1: Union[relativedelta, Timestamp],
     /,
     *,
-    precision: str = "seconds",
+    precision: _Precision = "seconds",
     max_units: int = 6,
     absolute: bool = True,
 ) -> str:
@@ -96,7 +97,7 @@ def humanize_delta(
     start: Timestamp,
     /,
     *,
-    precision: str = "seconds",
+    precision: _Precision = "seconds",
     max_units: int = 6,
     absolute: bool = True,
 ) -> str:
@@ -113,7 +114,7 @@ def humanize_delta(
     hours: float = 0,
     minutes: float = 0,
     seconds: float = 0,
-    precision: str = "seconds",
+    precision: _Precision = "seconds",
     max_units: int = 6,
     absolute: bool = True,
 ) -> str:
@@ -122,7 +123,7 @@ def humanize_delta(
 
 def humanize_delta(
     *args,
-    precision: str = "seconds",
+    precision: _Precision = "seconds",
     max_units: int = 6,
     absolute: bool = True,
     **kwargs,
-- 
cgit v1.2.3


From 2209b9f1b95cbe2366ea2b316046ddd35ff6d3a9 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 7 Aug 2021 10:48:57 -0700
Subject: Fix create_user_embed tests

Mock User.created_at and User.joined_at because `arrow.get()` doesn't
work with Mock objects. The old implementation of
`time.discord_timestamp` accepted mocks because it just did `int()` on
any type it didn't explicitly check for.
---
 tests/bot/exts/info/test_information.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index 30e5258fb..d896b7652 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -1,6 +1,7 @@
 import textwrap
 import unittest
 import unittest.mock
+from datetime import datetime
 
 import discord
 
@@ -288,6 +289,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         user.nick = None
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
+        user.created_at = user.joined_at = datetime.utcnow()
 
         embed = await self.cog.create_user_embed(ctx, user, False)
 
@@ -309,6 +311,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         user.nick = "Cat lover"
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
         user.colour = 0
+        user.created_at = user.joined_at = datetime.utcnow()
 
         embed = await self.cog.create_user_embed(ctx, user, False)
 
@@ -329,6 +332,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
 
         # A `MockMember` has the @Everyone role by default; we add the Admins to that.
         user = helpers.MockMember(roles=[admins_role], colour=100)
+        user.created_at = user.joined_at = datetime.utcnow()
 
         embed = await self.cog.create_user_embed(ctx, user, False)
 
@@ -355,6 +359,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         nomination_counts.return_value = ("Nominations", "nomination info")
 
         user = helpers.MockMember(id=314, roles=[moderators_role], colour=100)
+        user.created_at = user.joined_at = datetime.utcfromtimestamp(1)
         embed = await self.cog.create_user_embed(ctx, user, False)
 
         infraction_counts.assert_called_once_with(user)
@@ -394,6 +399,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         user_messages.return_value = ("Messages", "user message counts")
 
         user = helpers.MockMember(id=314, roles=[moderators_role], colour=100)
+        user.created_at = user.joined_at = datetime.utcfromtimestamp(1)
         embed = await self.cog.create_user_embed(ctx, user, False)
 
         infraction_counts.assert_called_once_with(user)
@@ -440,6 +446,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         moderators_role = helpers.MockRole(name='Moderators')
 
         user = helpers.MockMember(id=314, roles=[moderators_role], colour=100)
+        user.created_at = user.joined_at = datetime.utcnow()
         embed = await self.cog.create_user_embed(ctx, user, False)
 
         self.assertEqual(embed.colour, discord.Colour(100))
@@ -457,6 +464,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         ctx = helpers.MockContext()
 
         user = helpers.MockMember(id=217, colour=discord.Colour.default())
+        user.created_at = user.joined_at = datetime.utcnow()
         embed = await self.cog.create_user_embed(ctx, user, False)
 
         self.assertEqual(embed.colour, discord.Colour.og_blurple())
@@ -474,6 +482,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         ctx = helpers.MockContext()
 
         user = helpers.MockMember(id=217, colour=0)
+        user.created_at = user.joined_at = datetime.utcnow()
         user.display_avatar.url = "avatar url"
         embed = await self.cog.create_user_embed(ctx, user, False)
 
-- 
cgit v1.2.3


From 1af466753975b70effd5e600d0afc8b21f272dd0 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 7 Aug 2021 10:57:24 -0700
Subject: Time: return strings from until_expiration instead of ambiguous None

None was returned for two separate cases: permanent infractions and
expired infractions. This resulted in an ambiguity.
---
 bot/exts/moderation/infraction/management.py | 6 +++---
 bot/utils/time.py                            | 8 ++++----
 tests/bot/utils/test_time.py                 | 5 ++---
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 0dfd2d759..dda3fadae 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -179,8 +179,8 @@ class ModManagement(commands.Cog):
                 self.infractions_cog.schedule_expiration(new_infraction)
 
             log_text += f"""
-                Previous expiry: {time.until_expiration(infraction['expires_at']) or "Permanent"}
-                New expiry: {time.until_expiration(new_infraction['expires_at']) or "Permanent"}
+                Previous expiry: {time.until_expiration(infraction['expires_at'])}
+                New expiry: {time.until_expiration(new_infraction['expires_at'])}
             """.rstrip()
 
         changes = ' & '.join(confirm_messages)
@@ -362,7 +362,7 @@ class ModManagement(commands.Cog):
             user_str = f"<@{user['id']}> ({name}#{user['discriminator']:04})"
 
         if active:
-            remaining = time.until_expiration(expires_at) or "Expired"
+            remaining = time.until_expiration(expires_at)
         else:
             remaining = "Inactive"
 
diff --git a/bot/utils/time.py b/bot/utils/time.py
index 8ba49a455..4b2fbae2c 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -303,19 +303,19 @@ def format_with_duration(
     return f"{formatted_timestamp} ({duration})"
 
 
-def until_expiration(expiry: Optional[Timestamp]) -> Optional[str]:
+def until_expiration(expiry: Optional[Timestamp]) -> str:
     """
     Get the remaining time until an infraction's expiration as a Discord timestamp.
 
     `expiry` can be any type supported by the single-arg `arrow.get()`, except for a `tzinfo`.
 
-    Return None if `expiry` is falsy or is in the past.
+    Return "Permanent" if `expiry` is falsy. Return "Expired" if `expiry` is in the past.
     """
     if not expiry:
-        return None
+        return "Permanent"
 
     expiry = arrow.get(expiry)
     if expiry < arrow.utcnow():
-        return None
+        return "Expired"
 
     return format_relative(expiry)
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index e235f9b70..120d65176 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -100,8 +100,8 @@ class TimeTests(unittest.TestCase):
                 self.assertEqual(time.format_with_duration(expiry, date_from, max_units), expected)
 
     def test_until_expiration_with_duration_none_expiry(self):
-        """until_expiration should work for None expiry."""
-        self.assertEqual(time.until_expiration(None), None)
+        """until_expiration should return "Permanent" is expiry is None."""
+        self.assertEqual(time.until_expiration(None), "Permanent")
 
     def test_until_expiration_with_duration_custom_units(self):
         """until_expiration should work for custom max_units."""
@@ -122,7 +122,6 @@ class TimeTests(unittest.TestCase):
             ('3000-12-12T00:00:00Z', '<t:32533488000:R>'),
             ('3000-11-23T20:09:00Z', '<t:32531918940:R>'),
             ('3000-11-23T20:09:00Z', '<t:32531918940:R>'),
-            (None, None),
         )
 
         for expiry, expected in test_cases:
-- 
cgit v1.2.3


From 38e0789890ce9d3c7307de158c9277f6aa20b848 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 7 Aug 2021 11:01:30 -0700
Subject: Time: check timestamp for None only rather than if it's falsy

Integers and floats which are 0 are considered valid timestamps, but are
falsy.
---
 bot/utils/time.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index 4b2fbae2c..29fc46d56 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -292,9 +292,9 @@ def format_with_duration(
 
     `max_units` is forwarded to `time.humanize_delta`. See its documentation for more information.
 
-    Return None if `timestamp` is falsy.
+    Return None if `timestamp` is None.
     """
-    if not timestamp:
+    if timestamp is None:
         return None
 
     formatted_timestamp = discord_timestamp(timestamp)
@@ -309,9 +309,9 @@ def until_expiration(expiry: Optional[Timestamp]) -> str:
 
     `expiry` can be any type supported by the single-arg `arrow.get()`, except for a `tzinfo`.
 
-    Return "Permanent" if `expiry` is falsy. Return "Expired" if `expiry` is in the past.
+    Return "Permanent" if `expiry` is None. Return "Expired" if `expiry` is in the past.
     """
-    if not expiry:
+    if expiry is None:
         return "Permanent"
 
     expiry = arrow.get(expiry)
-- 
cgit v1.2.3


From e34d4cacb903cb155236c1c1c945d6159869fb59 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 23 Aug 2021 20:20:32 -0700
Subject: Time: put region comments around overloads

---
 bot/utils/time.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index 29fc46d56..005608beb 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -79,6 +79,7 @@ def discord_timestamp(timestamp: Timestamp, format: TimestampFormats = Timestamp
     return f"<t:{timestamp}:{format.value}>"
 
 
+# region humanize_delta overloads
 @overload
 def humanize_delta(
     arg1: Union[relativedelta, Timestamp],
@@ -119,6 +120,7 @@ def humanize_delta(
     absolute: bool = True,
 ) -> str:
     ...
+# endregion
 
 
 def humanize_delta(
-- 
cgit v1.2.3


From f6382a3eea81c1dd97b2e12fc81d42f8c77a4ae4 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 21 Sep 2021 21:51:20 -0700
Subject: Time: fix format_with_duration's 2nd arg's default

It wasn't passing the current time when `other_timestamp` was None.
---
 bot/utils/time.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index 005608beb..dfe65369e 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -299,6 +299,9 @@ def format_with_duration(
     if timestamp is None:
         return None
 
+    if other_timestamp is None:
+        other_timestamp = arrow.utcnow()
+
     formatted_timestamp = discord_timestamp(timestamp)
     duration = humanize_delta(timestamp, other_timestamp, max_units=max_units)
 
-- 
cgit v1.2.3


From 9f32831110ffa1d7c6cb9313c5bb56fa1c9f4d0b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 21 Sep 2021 22:02:16 -0700
Subject: TalentPool: fix typo in error message

---
 bot/exts/recruitment/talentpool/_cog.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/recruitment/talentpool/_cog.py b/bot/exts/recruitment/talentpool/_cog.py
index bbc135454..0554bf37a 100644
--- a/bot/exts/recruitment/talentpool/_cog.py
+++ b/bot/exts/recruitment/talentpool/_cog.py
@@ -259,7 +259,7 @@ class TalentPool(Cog, name="Talentpool"):
             return
 
         if len(reason) > REASON_MAX_CHARS:
-            await ctx.send(f":x: Maxiumum allowed characters for the reason is {REASON_MAX_CHARS}.")
+            await ctx.send(f":x: Maximum allowed characters for the reason is {REASON_MAX_CHARS}.")
             return
 
         # Manual request with `raise_for_status` as False because we want the actual response
@@ -444,7 +444,7 @@ class TalentPool(Cog, name="Talentpool"):
     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:
-            await ctx.send(f":x: Maxiumum allowed characters for the end reason is {REASON_MAX_CHARS}.")
+            await ctx.send(f":x: Maximum allowed characters for the end reason is {REASON_MAX_CHARS}.")
             return
 
         try:
-- 
cgit v1.2.3


From dfa5af2036801124a820891dfa69c0c8884aaa03 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 9 Jan 2022 17:12:49 -0800
Subject: Converters: use datetime.timezone instead of dateutil.tz

They're equivalent for UTC. Get rid of the extra import.
---
 bot/converters.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/bot/converters.py b/bot/converters.py
index b68c4d623..1865c705c 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -6,7 +6,6 @@ from datetime import datetime, timezone
 from ssl import CertificateError
 
 import dateutil.parser
-import dateutil.tz
 import discord
 from aiohttp import ClientConnectorError
 from dateutil.relativedelta import relativedelta
@@ -454,9 +453,9 @@ class ISODateTime(Converter):
             raise BadArgument(f"`{datetime_string}` is not a valid ISO-8601 datetime string")
 
         if dt.tzinfo:
-            dt = dt.astimezone(dateutil.tz.UTC)
+            dt = dt.astimezone(timezone.utc)
         else:  # Without a timezone, assume it represents UTC.
-            dt = dt.replace(tzinfo=dateutil.tz.UTC)
+            dt = dt.replace(tzinfo=timezone.utc)
 
         return dt
 
-- 
cgit v1.2.3


From bdf43f4ced428ce092ac2e24cdcf7d47c9995ff0 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 9 Jan 2022 17:17:03 -0800
Subject: Scheduling: add Arrow to schedule_at's type annotations

---
 bot/utils/scheduling.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/bot/utils/scheduling.py b/bot/utils/scheduling.py
index 7b4c8e2de..23acacf74 100644
--- a/bot/utils/scheduling.py
+++ b/bot/utils/scheduling.py
@@ -5,6 +5,8 @@ import typing as t
 from datetime import datetime
 from functools import partial
 
+from arrow import Arrow
+
 from bot.log import get_logger
 
 
@@ -58,7 +60,7 @@ class Scheduler:
         self._scheduled_tasks[task_id] = task
         self._log.debug(f"Scheduled task #{task_id} {id(task)}.")
 
-    def schedule_at(self, time: datetime, task_id: t.Hashable, coroutine: t.Coroutine) -> None:
+    def schedule_at(self, time: t.Union[datetime, Arrow], task_id: t.Hashable, coroutine: t.Coroutine) -> None:
         """
         Schedule `coroutine` to be executed at the given `time`.
 
-- 
cgit v1.2.3


From 5092205a62ffe97855f377e46e4cfc63836cff19 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 9 Jan 2022 17:24:54 -0800
Subject: Time: revise docstrings

---
 bot/utils/time.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/bot/utils/time.py b/bot/utils/time.py
index dfe65369e..a0379c3ef 100644
--- a/bot/utils/time.py
+++ b/bot/utils/time.py
@@ -50,7 +50,7 @@ class TimestampFormats(Enum):
 
 def _stringify_time_unit(value: int, unit: str) -> str:
     """
-    Returns a string to represent a value and time unit, ensuring that it uses the right plural form of the unit.
+    Return a string to represent a value and time unit, ensuring the unit's correct plural form is used.
 
     >>> _stringify_time_unit(1, "seconds")
     "1 second"
@@ -213,7 +213,7 @@ def humanize_delta(
         ("seconds", delta.seconds),
     )
 
-    # Add the time units that are >0, but stop at accuracy or max_units.
+    # Add the time units that are >0, but stop at precision or max_units.
     time_strings = []
     unit_count = 0
     for unit, value in units:
@@ -224,7 +224,7 @@ def humanize_delta(
         if unit == precision or unit_count >= max_units:
             break
 
-    # Add the 'and' between the last two units, if necessary
+    # Add the 'and' between the last two units, if necessary.
     if len(time_strings) > 1:
         time_strings[-1] = f"{time_strings[-2]} and {time_strings[-1]}"
         del time_strings[-2]
@@ -240,9 +240,10 @@ def humanize_delta(
 
 def parse_duration_string(duration: str) -> Optional[relativedelta]:
     """
-    Converts a `duration` string to a relativedelta object.
+    Convert a `duration` string to a relativedelta object.
+
+    The following symbols are supported for each unit of time:
 
-    The function supports the following symbols for each unit of time:
     - years: `Y`, `y`, `year`, `years`
     - months: `m`, `month`, `months`
     - weeks: `w`, `W`, `week`, `weeks`
@@ -250,8 +251,9 @@ def parse_duration_string(duration: str) -> Optional[relativedelta]:
     - hours: `H`, `h`, `hour`, `hours`
     - minutes: `M`, `minute`, `minutes`
     - seconds: `S`, `s`, `second`, `seconds`
+
     The units need to be provided in descending order of magnitude.
-    If the string does represent a durationdelta object, it will return None.
+    Return None if the `duration` string cannot be parsed according to the symbols above.
     """
     match = _DURATION_REGEX.fullmatch(duration)
     if not match:
@@ -264,7 +266,7 @@ def parse_duration_string(duration: str) -> Optional[relativedelta]:
 
 
 def relativedelta_to_timedelta(delta: relativedelta) -> datetime.timedelta:
-    """Converts a relativedelta object to a timedelta object."""
+    """Convert a relativedelta object to a timedelta object."""
     utcnow = arrow.utcnow()
     return utcnow + delta - utcnow
 
-- 
cgit v1.2.3