Normalizing datetimes to utc. Fixing datatype conversions on guild settings

rocketbot/bot.py

 		return
 	bot_log(None, None, 'Creating bot...')
 	intents = Intents.default()
-	intents.messages = True
 	intents.message_content = True
 	intents.members = True
 	intents.presences = False

rocketbot/botmessage.py

 
 from config import CONFIG
 from rocketbot.storage import ConfigKey, Storage
-from rocketbot.utils import bot_log
+from rocketbot.utils import bot_log, norm_datetime
 
 
 class BotMessageReaction:
 
 	def message_sent_at(self) -> Optional[datetime]:
 		"""Returns when the message was sent or None if not sent."""
-		return self.__messages[0].created_at if len(self.__messages) > 0 else None
+		return norm_datetime(self.__messages[0].created_at) if len(self.__messages) > 0 else None
 
 	def has_reactions(self) -> bool:
 		"""Whether this message has any reactions defined."""

rocketbot/cogs/autokickcog.py

-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from discord import Guild, Member, Status
 from discord.ext import tasks
 class StatusCheckContext:
 	def __init__(self, member: Member):
 		self.member = member
-		self.joined_at = datetime.now()
+		self.joined_at = datetime.now(timezone.utc)
 
 class AutoKickCog(BaseCog, name='Auto Kick'):
 	"""
 		"""Checks status of new members shortly after joining to see if they go offline"""
 		contexts = self.status_check_members.copy()
 		self.status_check_members = []
-		now = datetime.now()
+		now = datetime.now(timezone.utc)
 		# bot_log(guild=None, cog_class=None, message=f'Found {len(contexts)} members to check')
 		for c in contexts:
 			context: StatusCheckContext = c
 			Storage.set_state_value(guild, self.STATE_KEY_RECENT_KICKS, recent_kicks)
 		context: AutoKickContext = recent_kicks.get(member.id)
 		if context is None:
-			context = AutoKickContext(member, datetime.now())
+			context = AutoKickContext(member, datetime.now(timezone.utc))
 			recent_kicks[member.id] = context
 		else:
-			context.record_kick(datetime.now())
+			context.record_kick(datetime.now(timezone.utc))
 		max_kick_count: int = self.get_guild_setting(guild, self.SETTING_BAN_COUNT)
 		disable_help = 'To disable this feature: `/disable autokick`.'
 		ban_help = 'To configure ban threshold: `/set autokick_bancount #` (0 to disable)'

rocketbot/cogs/basecog.py

 from rocketbot.cogsetting import CogSetting
 from rocketbot.collections import AgeBoundDict
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log, dump_stacktrace
+from rocketbot.utils import bot_log, dump_stacktrace, norm_datetime
 
 
 class WarningContext:
 		"""
 		if guild:
 			key = f'{cls.__name__}.{setting.name}'
-			value = Storage.get_config_value(guild, key)
-			if value is not None:
-				return value
+			stored_value = Storage.get_config_value(guild, key)
+			if stored_value is not None:
+				return setting.to_native_value(stored_value)
 		if use_cog_default_if_not_set:
 			return setting.default_value
 		return None
 		"""
 		setting.validate_value(new_value)
 		key = f'{cls.__name__}.{setting.name}'
-		Storage.set_config_value(guild, key, new_value)
+		stored_value = setting.to_stored_value(new_value)
+		Storage.set_config_value(guild, key, stored_value)
 
 	# @commands.Cog.listener()
 	async def __on_ready(self):
 		if context is None:
 			return False
 		squelch_warning_seconds: int = CONFIG['squelch_warning_seconds']
-		return datetime.now() - context.last_warned < timedelta(seconds=squelch_warning_seconds)
+		return datetime.now(timezone.utc) - context.last_warned < timedelta(seconds=squelch_warning_seconds)
 
 	def record_warning(self, member: Member):
 		"""
 			Storage.set_state_value(member.guild, BaseCog.STATE_KEY_RECENT_WARNINGS, recent_warns)
 		context: WarningContext = recent_warns.get(member.id)
 		if context is None:
-			context = WarningContext(member, datetime.now())
+			context = WarningContext(member, datetime.now(timezone.utc))
 			recent_warns[member.id] = context
 		else:
-			context.last_warned = datetime.now()
+			context.last_warned = datetime.now(timezone.utc)
 
 	def record_warnings(self, members: list[Member]):
 		"""
 		if bm is None:
 			far_future = datetime.now(timezone.utc) + timedelta(days=1000)
 			bm = AgeBoundDict(timedelta(seconds=600),
-				lambda k, v : v.message_sent_at() or far_future)
+				lambda k, v : norm_datetime(v.message_sent_at()) or far_future)
 			Storage.set_state_value(guild, 'bot_messages', bm)
 		return bm
 

rocketbot/cogs/crosspostcog.py

 Cog for detecting spam messages posted in multiple channels.
 """
 import re
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Optional
 
 from discord import Member, Message, TextChannel
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from rocketbot.collections import AgeBoundDict, AgeBoundList
 from rocketbot.storage import Storage
-from rocketbot.utils import str_from_timedelta
+from rocketbot.utils import norm_datetime, str_from_timedelta
 
 
 class SpamContext:
 	"""
 	def __init__(self, member: Member) -> None:
 		self.member: Member = member
-		self.age: datetime = datetime.now()
+		self.age: datetime = datetime.now(timezone.utc)
 		self.bot_message: Optional[BotMessage] = None
 		self.is_kicked: bool = False
 		self.is_banned: bool = False
 			self.__trace(f"Hash for message #{m.id} by {m.author.name} is {h}\n\thash content: \"{to_hash}\"")
 			return h
 
-		min_length = self.get_guild_setting(message.guild, self.SETTING_MIN_LENGTH)
+		min_length: int = self.get_guild_setting(message.guild, self.SETTING_MIN_LENGTH)
 		if len(message.attachments) == 0 and len(message.content) < min_length:
 			# Message too short to count towards spam total
 			self.__trace(f"Message len {len(message.content)} < {min_length} configured min")
 			return
 
 		# Get config
-		max_age = timedelta(seconds=self.get_guild_setting(message.guild, self.SETTING_TIMESPAN))
+		max_age: timedelta = self.get_guild_setting(message.guild, self.SETTING_TIMESPAN)
 		warn_count: int = self.get_guild_setting(message.guild, self.SETTING_WARN_COUNT)
 		dupe_warn_count: int = self.get_guild_setting(message.guild, self.SETTING_DUPE_WARN_COUNT)
 
 		# Record message
 		recent_messages: AgeBoundList[Message, datetime, timedelta] = Storage.get_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES)
 		if recent_messages is None:
-			recent_messages = AgeBoundList(max_age, lambda index, message : message.created_at)
+			recent_messages = AgeBoundList(max_age, lambda index, message : norm_datetime(message.created_at))
 			Storage.set_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES, recent_messages)
 		recent_messages.max_age = max_age
 		recent_messages.append(message)
 			self.log(message.guild,
 				f'\u0007{message.author.name} ({message.author.id}) ' + \
 				f'posted messages in {channel_count} channels.')
-		context.age = message.created_at
+		context.age = norm_datetime(message.created_at)
 		context.duplicate_count = max_duplicate_count
 		context.spam_messages.update(member_messages)
 		context.unique_channels.update(unique_channels)
 		await self.__update_from_context(context)
 
 	async def __update_from_context(self, context: SpamContext):
-		ban_count = self.get_guild_setting(context.member.guild, self.SETTING_BAN_COUNT)
-		dupe_ban_count = self.get_guild_setting(context.member.guild, self.SETTING_DUPE_BAN_COUNT)
+		ban_count: int = self.get_guild_setting(context.member.guild, self.SETTING_BAN_COUNT)
+		dupe_ban_count: int = self.get_guild_setting(context.member.guild, self.SETTING_DUPE_BAN_COUNT)
 		channel_count = len(context.unique_channels)
 		if channel_count >= ban_count or context.duplicate_count >= dupe_ban_count:
 			if not context.is_banned:
-				max_age = timedelta(seconds=self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN))
+				max_age: timedelta = self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN)
 				max_age_str = str_from_timedelta(max_age)
 				await context.member.ban(
 					reason=f'Rocketbot: Posted in {channel_count} channels within {max_age_str} ' + \
 		channel_count = len(context.unique_channels)
 		deleted_count = len(context.deleted_messages)
 		duplicate_count = context.duplicate_count
-		max_age = timedelta(seconds=self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN))
+		max_age: timedelta = self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN)
 		max_age_str = str_from_timedelta(max_age)
 		message = context.bot_message
 		if message is None:
 			self.__log_ban(context, reacted_by.name)
 
 	def __log_deletion(self, context: SpamContext, by_who: str) -> None:
-		max_age = timedelta(seconds=self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN))
+		max_age: timedelta = self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN)
 		max_age_str = str_from_timedelta(max_age)
 		channel_count = len(context.unique_channels)
 		duplicate_count = context.duplicate_count
 				 f'({duplicate_count} identical). Deleted by {by_who}.')
 
 	def __log_kick(self, context: SpamContext, by_who: str) -> None:
-		max_age = timedelta(seconds=self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN))
+		max_age: timedelta = self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN)
 		max_age_str = str_from_timedelta(max_age)
 		channel_count = len(context.unique_channels)
 		duplicate_count = context.duplicate_count
 				 f'({duplicate_count} identical). Kicked by {by_who}.')
 
 	def __log_ban(self, context: SpamContext, by_who: str) -> None:
-		max_age = timedelta(seconds=self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN))
+		max_age: timedelta = self.get_guild_setting(context.member.guild, self.SETTING_TIMESPAN)
 		max_age_str = str_from_timedelta(max_age)
 		channel_count = len(context.unique_channels)
 		duplicate_count = context.duplicate_count

rocketbot/cogs/joinraidcog.py

 		guild: Guild = member.guild
 		if not self.get_guild_setting(guild, self.SETTING_ENABLED):
 			return
-		min_count = self.get_guild_setting(guild, self.SETTING_JOIN_COUNT)
-		seconds = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
-		timespan: timedelta = timedelta(seconds=seconds)
+		min_count: int = self.get_guild_setting(guild, self.SETTING_JOIN_COUNT)
+		timespan: timedelta = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
 
 		last_raid: JoinRaidContext = Storage.get_state_value(guild, self.STATE_KEY_LAST_RAID)
 		recent_joins: AgeBoundList[Member, datetime, timedelta] = Storage.get_state_value(guild, self.STATE_KEY_RECENT_JOINS)
 
 	async def on_setting_updated(self, guild: Guild, setting: CogSetting) -> None:
 		if setting is self.SETTING_JOIN_TIME:
-			seconds = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
-			timespan: timedelta = timedelta(seconds=seconds)
+			timespan: timedelta = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
 			recent_joins: AgeBoundList[Member, datetime, timedelta] = Storage.get_state_value(guild,
 				self.STATE_KEY_RECENT_JOINS)
 			if recent_joins:

rocketbot/cogs/logcog.py

 
 from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
 from rocketbot.storage import Storage
-from rocketbot.utils import dump_stacktrace
+from rocketbot.utils import dump_stacktrace, norm_datetime
 
 
 class BufferedMessageEditEvent:
 			pass  # not that interesting and probably noisy
 		if after.timed_out_until != before.timed_out_until:
 			if after.timed_out_until:
-				delta = after.timed_out_until - datetime.now()
+				delta = after.timed_out_until - datetime.now(timezone.utc)
 				changes.append(f'Timed out for `{delta}`')
 			elif before.timed_out_until:
 				changes.append('Timeout cleared')
 			guild = user.guild
 		else:
 			return None
-		now = datetime.now()
+		now = datetime.now(timezone.utc)
 		async for entry in guild.audit_logs():
 			age_seconds = now.timestamp() - entry.created_at.timestamp()
 			if entry.action == action and entry.target == user and age_seconds <= max_age:
 
 		https://discordpy.readthedocs.io/en/stable/api.html#discord.on_message
 		"""
-		# print(f"Saw message {message.id} \"{message.content}\"")
+		# print(f"on_message:"
+		# 	f"\n\tid: {message.id}"
+		# 	f"\n\tauthor: {message.author.name}"
+		# 	f"\n\tchannel: {message.channel.name}"
+		# 	f"\n\tcontent: \"{message.content}\""
+		# 	f"\n\tattachments: x{len(message.attachments)}"
+		# 	f"\n\tembeds: x{len(message.embeds)}"
+		# 	f"\n\tcomponents: x{len(message.components)}")
 
 	@Cog.listener()
 	async def on_message_edit(self, before: Message, after: Message) -> None:
 		old_cutoff = timedelta(days=1)
 		now = datetime.now(timezone.utc)
 		for event in events:
-			if event.before is not None and (now - event.after.created_at) < old_cutoff:
+			if event.before is not None and (now - norm_datetime(event.after.created_at)) < old_cutoff:
 				simple_edits.append(event)
 			else:
 				complex_edits.append(event)

rocketbot/cogs/patterncog.py

 	PatternStatement,
 )
 from rocketbot.storage import Storage
-from rocketbot.utils import MOD_PERMISSIONS, dump_stacktrace
+from rocketbot.utils import MOD_PERMISSIONS, dump_stacktrace, norm_datetime
 
 
 class PatternContext:
 		if last_matched is None:
 			last_matched = {}
 			Storage.set_state_value(guild, 'PatternCog.last_matched', last_matched)
-		last_matched[name] = time
+		last_matched[name] = norm_datetime(time)
 
 	@Cog.listener()
 	async def on_message(self, message: Message) -> None:

rocketbot/cogs/urlspamcog.py

 
 from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
-from rocketbot.utils import describe_timedelta
+from rocketbot.utils import describe_timedelta, norm_datetime
 
 
 class URLSpamContext:
 
 	async def check_message_recency(self, message: Message):
 		"""Checks if the message was sent too recently by a new user"""
-		action = self.get_guild_setting(message.guild, self.SETTING_ACTION)
-		join_seconds = self.get_guild_setting(message.guild, self.SETTING_JOIN_AGE)
-		min_join_age = timedelta(seconds=join_seconds)
+		action: str = self.get_guild_setting(message.guild, self.SETTING_ACTION)
+		min_join_age: timedelta = self.get_guild_setting(message.guild, self.SETTING_JOIN_AGE)
 		if action == 'nothing':
 			self.__trace("Configured action is nothing")
 			return
-		join_age = message.created_at - message.author.joined_at
+		join_age = norm_datetime(message.created_at) - norm_datetime(message.author.joined_at)
 		join_age_str = describe_timedelta(join_age)
 		if join_age > min_join_age:
 			self.__trace("User has been member long enough")

rocketbot/cogs/videopreviewcog.py

 
 	async def _wait_for_preview(self, message: Message, links: list[MessageLink]):
 		Self = VideoPreviewCog
-		await asyncio.sleep(self.get_guild_setting(message.guild, Self.SETTING_DELAY))
+		delay: timedelta = self.get_guild_setting(message.guild, Self.SETTING_DELAY)
+		await asyncio.sleep(delay.total_seconds())
 		# Look for embeds already showing the video
 		self.log(message.guild, "Checking message for embeds")
 		for embed in message.embeds:

rocketbot/cogsetting.py

 
 	def to_stored_value(self, native_value: Any) -> Any:
 		"""Converts a configuration value to a JSON-compatible datatype."""
+		if native_value is None:
+			return None
 		if self.datatype is timedelta:
 			return native_value.total_seconds()
 		return native_value
 
 	def to_native_value(self, stored_value: Any) -> Any:
 		"""Converts the stored JSON-compatible datatype to its actual value."""
+		if stored_value is None:
+			return None
 		if self.datatype is timedelta and isinstance(stored_value, (int, float)):
 			return timedelta(seconds=stored_value)
 		return stored_value

rocketbot/pattern.py

 
 from rocketbot.utils import (
 	is_user_id,
+	norm_datetime,
 	str_from_quoted_str,
 	timedelta_from_str,
 	user_id_from_mention,
 		if self.field in (cls.FIELD_AUTHOR_ID, cls.ALIAS_FIELD_AUTHOR_ID):
 			return str(message.author.id)
 		if self.field == cls.FIELD_AUTHOR_JOINAGE:
-			return message.created_at - message.author.joined_at
+			return norm_datetime(message.created_at) - norm_datetime(message.author.joined_at)
 		if self.field == cls.FIELD_AUTHOR_NAME:
 			return message.author.name
 		if self.field == cls.FIELD_LAST_MATCHED:
 			long_ago = datetime(year=1900, month=1, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc)
 			last_matched = other_fields.get('last_matched') or long_ago
-			return message.created_at - last_matched
+			return norm_datetime(message.created_at) - norm_datetime(last_matched)
 		raise ValueError(f'Bad field name "{self.field}"')
 
 	def matches(self, message: Message, other_fields: dict[str, Any]) -> bool:

rocketbot/storage.py

 
 from config import CONFIG
 from rocketbot.collections import AgeBoundDict
+from rocketbot.utils import norm_datetime
 
 
 class ConfigKey:
 		if bm is None:
 			far_future = datetime.now(timezone.utc) + timedelta(days=1000)
 			bm = AgeBoundDict(timedelta(seconds=600),
-				lambda k, v : v.message_sent_at() or far_future)
+				lambda k, v : norm_datetime(v.message_sent_at()) or far_future)
 			Storage.set_state_value(guild, 'bot_messages', bm)
 		return bm
 

rocketbot/utils.py

 import re
 import sys
 import traceback
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Any, Optional, Union
 
 import discord
 		return f"{size/gib:,.1f} GiB"
 	return f"{size/gib:,.0f} GiB"
 
+def norm_datetime(dt: datetime) -> datetime:
+	"""Converts a datetime to UTC for consistent comparison."""
+	# "Naive" datetimes (without a time zone) are assumed as system local time zone
+	return datetime.fromtimestamp(dt.timestamp(), timezone.utc)
+
 MOD_PERMISSIONS: Permissions = Permissions(Permissions.manage_messages.flag)
 
 class TimeDeltaTransformer(Transformer):