Switching to Ruff, addressing warnings

rocketbot/bot.py

 		self.__first_ready = True
 
 	async def on_command_error(self, context: commands.Context, exception: BaseException) -> None:
-		bot_log(None, None, f'Command error')
+		bot_log(None, None, 'Command error')
 		dump_stacktrace(exception)
 		if context.guild is None or \
 				context.message.channel is None or \
 			if not self.__commands_set_up:
 				await self.__set_up_commands()
 			bot_log(None, None, 'Bot done initializing')
-			bot_log(None, None, f"Type /help in Discord for available commands.")
+			bot_log(None, None, "Type /help in Discord for available commands.")
 			print('----------------------------------------------------------')
 
 	async def __set_up_commands(self):
 	rocketbot = Rocketbot(intents=intents)
 __create_bot()
 
-from rocketbot.cogs.autokickcog import AutoKickCog
-from rocketbot.cogs.bangcommandcog import BangCommandCog
-from rocketbot.cogs.configcog import ConfigCog
-from rocketbot.cogs.crosspostcog import CrossPostCog
-from rocketbot.cogs.gamescog import GamesCog
-from rocketbot.cogs.generalcog import GeneralCog
-from rocketbot.cogs.helpcog import HelpCog
-from rocketbot.cogs.joinraidcog import JoinRaidCog
-from rocketbot.cogs.logcog import LoggingCog
-from rocketbot.cogs.patterncog import PatternCog
-from rocketbot.cogs.urlspamcog import URLSpamCog
-from rocketbot.cogs.usernamecog import UsernamePatternCog
-
 async def start_bot():
+	from rocketbot.cogs.autokickcog import AutoKickCog
+	from rocketbot.cogs.bangcommandcog import BangCommandCog
+	from rocketbot.cogs.configcog import ConfigCog
+	from rocketbot.cogs.crosspostcog import CrossPostCog
+	from rocketbot.cogs.gamescog import GamesCog
+	from rocketbot.cogs.generalcog import GeneralCog
+	from rocketbot.cogs.helpcog import HelpCog
+	from rocketbot.cogs.joinraidcog import JoinRaidCog
+	from rocketbot.cogs.logcog import LoggingCog
+	from rocketbot.cogs.patterncog import PatternCog
+	from rocketbot.cogs.urlspamcog import URLSpamCog
+	from rocketbot.cogs.usernamecog import UsernamePatternCog
+
 	bot_log(None, None, 'Bot initializing...')
 
 	# Core

rocketbot/botmessage.py

 Classes for crafting messages from the bot. Content can change as information
 changes, and mods can perform actions on the message via emoji reactions.
 """
-from typing import Any, Optional, Union
-
 from datetime import datetime
+from typing import Any, Optional, Union
 
 from discord import Guild, Message, PartialEmoji, TextChannel
 
 from rocketbot.storage import ConfigKey, Storage
 from rocketbot.utils import bot_log
 
+
 class BotMessageReaction:
 	"""
 	A possible reaction to a bot message that will trigger an action. The list

rocketbot/cogs/autokickcog.py

 from discord.ext.commands import Cog
 from discord.ext.tasks import Loop
 
-from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
 from rocketbot.collections import AgeBoundDict
 from rocketbot.storage import Storage
 
+
 class AutoKickContext:
 	"""
 	Data about a join raid.
 		else:
 			context.record_kick(datetime.now())
 		max_kick_count: int = self.get_guild_setting(guild, self.SETTING_BAN_COUNT)
-		disable_help = f'To disable this feature: `/disable autokick`.'
-		ban_help = f'To configure ban threshold: `/set autokick_bancount #` (0 to disable)'
+		disable_help = 'To disable this feature: `/disable autokick`.'
+		ban_help = 'To configure ban threshold: `/set autokick_bancount #` (0 to disable)'
 		if max_kick_count > 0 and context.kick_count > max_kick_count:
 			await member.ban(reason=f'Rocketbot: Ban after {context.kick_count} joins',
 				delete_message_days=0)

rocketbot/cogs/bangcommandcog.py

 import re
 from typing import Optional, TypedDict
 
-from discord import Interaction, Guild, Message, TextChannel, SelectOption, TextStyle
-from discord.app_commands import Group, Choice, autocomplete
+from discord import Guild, Interaction, Message, SelectOption, TextChannel, TextStyle
+from discord.app_commands import Choice, Group, autocomplete
 from discord.ext.commands import Cog
-from discord.ui import Modal, Label, Select, TextInput
+from discord.ui import Label, Modal, Select, TextInput
 
 from config import CONFIG
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog
 from rocketbot.cogsetting import CogSetting
-from rocketbot.ui.pagedcontent import PAGE_BREAK, update_paged_content, paginate
-from rocketbot.utils import MOD_PERMISSIONS, blockquote_markdown, indent_markdown, dump_stacktrace
+from rocketbot.ui.pagedcontent import PAGE_BREAK, paginate, update_paged_content
+from rocketbot.utils import (
+	MOD_PERMISSIONS,
+	blockquote_markdown,
+	dump_stacktrace,
+	indent_markdown,
+)
 
 _CURRENT_DATA_VERSION = 1
 _MAX_CONTENT_LENGTH = 2000
 		mod_only_input: Select = self.mod_only_label.component
 		name_input.default = name
 		content_input.default = content
-		mod_only_input.options[0].default = mod_only != True
-		mod_only_input.options[1].default = mod_only == True
+		resolved_mod_only = mod_only if mod_only is not None else False
+		mod_only_input.options[0].default = not resolved_mod_only
+		mod_only_input.options[1].default = resolved_mod_only
 
 	async def on_submit(self, interaction: Interaction) -> None:
 		# noinspection PyTypeChecker
 				f'{CONFIG["failure_emoji"]} Save failed',
 				ephemeral=True,
 			)
-		except:
+		except BaseException:
 			pass

rocketbot/cogs/basecog.py

 from typing import Optional
 
 import discord
-from discord import Guild, Interaction, Member, Message, RawReactionActionEvent, TextChannel
+from discord import (
+	Guild,
+	Interaction,
+	Member,
+	Message,
+	RawReactionActionEvent,
+	TextChannel,
+)
 from discord.abc import GuildChannel
 from discord.app_commands import AppCommandError
 from discord.app_commands.errors import CommandInvokeError
 from rocketbot.storage import Storage
 from rocketbot.utils import bot_log, dump_stacktrace
 
+
 class WarningContext:
 	def __init__(self, member: Member, warn_time: datetime):
 		self.member = member

rocketbot/cogs/configcog.py

 """
 Cog handling general configuration for a guild.
 """
-from typing import Union, Optional
+from typing import Optional, Union
 
-from discord import Guild, Permissions, TextChannel, Interaction, Role, User
+from discord import Guild, Interaction, Role, TextChannel, User
 from discord.app_commands import Group
 from discord.ext.commands import Bot
 
 from config import CONFIG
-from rocketbot.storage import ConfigKey, Storage
 from rocketbot.cogs.basecog import BaseCog
+from rocketbot.storage import ConfigKey, Storage
 from rocketbot.utils import MOD_PERMISSIONS
 
 

rocketbot/cogs/crosspostcog.py

 from datetime import datetime, timedelta
 from typing import Optional
 
-from discord import Member, Message, utils as discordutils, TextChannel
+from discord import Member, Message, TextChannel
+from discord import utils as discordutils
 from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
-from rocketbot.collections import AgeBoundList, AgeBoundDict
+from rocketbot.collections import AgeBoundDict, AgeBoundList
 from rocketbot.storage import Storage
 from rocketbot.utils import str_from_timedelta
 

rocketbot/cogs/gamescog.py

 import math
 import random
-from time import perf_counter
 
 from discord import Interaction, UnfurledMediaItem
-from discord.app_commands import command, Range, guild_only
-from discord.ui import LayoutView, Section, TextDisplay, Thumbnail, Container
+from discord.app_commands import Range, command, guild_only
+from discord.ui import Container, LayoutView, Section, TextDisplay, Thumbnail
 
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog

rocketbot/cogs/generalcog.py

 from typing import Optional
 
 from discord import Interaction, Message, User
-from discord.app_commands import command, default_permissions, guild_only, Transform
+from discord.app_commands import Transform, command, default_permissions, guild_only
 from discord.errors import DiscordException
 from discord.ext.commands import Cog
 
 from config import CONFIG
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage
-from rocketbot.utils import describe_timedelta, TimeDeltaTransformer
 from rocketbot.storage import ConfigKey, Storage
+from rocketbot.utils import TimeDeltaTransformer, describe_timedelta
+
 
 class GeneralCog(BaseCog, name='General'):
 	"""

rocketbot/cogs/helpcog.py

 """Provides help commands for getting info on using other commands and configuration."""
 import re
 import time
-from typing import Union, Optional, TypedDict
-
-from discord import Interaction, Permissions, AppCommandType
-from discord.app_commands import Group, Command, autocomplete, guild_only, command, Choice
+from typing import Optional, TypedDict, Union
+
+from discord import AppCommandType, Interaction, Permissions
+from discord.app_commands import (
+	Choice,
+	Command,
+	Group,
+	autocomplete,
+	command,
+	guild_only,
+)
 
 from config import CONFIG
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog
-from rocketbot.ui.pagedcontent import update_paged_content, paginate
+from rocketbot.ui.pagedcontent import paginate, update_paged_content
 from rocketbot.utils import MOD_PERMISSIONS, dump_stacktrace
 
 HelpTopic = Union[Command, Group, BaseCog]
 			   (len(cog_tuple[1].settings) > 0)
 		]
 
-		text = f'## :information_source: Help'
+		text = '## :information_source: Help'
 		if len(all_commands) + len(all_cog_tuples) == 0:
 			text = 'Nothing available for your permissions!'
 
 		if addendum is not None:
 			text += addendum + '\n\n'
 		if command_or_group.parent:
-			text += f'## :information_source: Subcommand Help'
+			text += '## :information_source: Subcommand Help'
 			text += f'\n`/{command_or_group.parent.name} {command_or_group.name}`'
 		else:
-			text += f'## :information_source: Command Help'
+			text += '## :information_source: Command Help'
 			if isinstance(command_or_group, Group):
 				text += f'\n`/{command_or_group.name} subcommand_name`'
 			else:
 		await self.__send_paged_help(interaction, text)
 
 	async def __send_cog_help(self, interaction: Interaction, cog: BaseCog) -> None:
-		text = f'## :information_source: Module Help'
+		text = '## :information_source: Module Help'
 		text += f'\n**{cog.qualified_name}** module'
 		if cog.short_description is not None:
 			text += f'\n\n{cog.short_description}'

rocketbot/cogs/joinraidcog.py

 """
 import weakref
 from datetime import datetime, timedelta
+
 from discord import Guild, Member
 from discord.ext.commands import Cog
 
 from rocketbot.collections import AgeBoundList
 from rocketbot.storage import Storage
 
+
 class JoinRaidContext:
 	"""
 	Data about a join raid.

rocketbot/cogs/logcog.py

 """
 Cog for detecting large numbers of guild joins in a short period of time.
 """
+import difflib
+import re
 from collections.abc import Sequence
 from datetime import datetime, timedelta, timezone
-
-from discord import AuditLogAction, AuditLogEntry, Emoji, Guild, GuildSticker, Invite, Member, Message, RawBulkMessageDeleteEvent, RawMessageDeleteEvent, RawMessageUpdateEvent, Role, Thread, User
+from typing import Callable, Optional, Tuple, Union
+
+from discord import (
+	AuditLogAction,
+	AuditLogEntry,
+	Emoji,
+	Guild,
+	GuildSticker,
+	Invite,
+	Member,
+	Message,
+	RawBulkMessageDeleteEvent,
+	RawMessageDeleteEvent,
+	RawMessageUpdateEvent,
+	Role,
+	Thread,
+	User,
+)
 from discord.abc import GuildChannel
 from discord.ext import tasks
 from discord.ext.commands import Cog
 from discord.utils import escape_markdown
-from typing import Optional, Tuple, Union, Callable
-import difflib
-import re
 
 from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
 from rocketbot.storage import Storage

rocketbot/cogs/patterncog.py

 from datetime import datetime
 from typing import Optional
 
-from discord import Guild, Member, Message, utils as discordutils, Interaction
+from discord import Guild, Interaction, Member, Message
+from discord import utils as discordutils
 from discord.app_commands import Choice, Group, autocomplete
 from discord.ext.commands import Cog
 
 from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction
 from rocketbot.cogsetting import CogSetting
-from rocketbot.pattern import PatternCompiler, PatternDeprecationError, \
-	PatternError, PatternStatement
+from rocketbot.pattern import (
+	PatternCompiler,
+	PatternDeprecationError,
+	PatternError,
+	PatternStatement,
+)
 from rocketbot.storage import Storage
-from rocketbot.utils import dump_stacktrace, MOD_PERMISSIONS
+from rocketbot.utils import MOD_PERMISSIONS, dump_stacktrace
 
 
 class PatternContext:

rocketbot/cogs/urlspamcog.py

 from datetime import timedelta
 from typing import Literal
 
-from discord import Member, Message, utils as discordutils
+from discord import Member, Message
+from discord import utils as discordutils
 from discord.ext.commands import Cog
 from discord.utils import escape_markdown
 
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from rocketbot.utils import describe_timedelta
 
+
 class URLSpamContext:
 	"""
 	Data about a suspected spam message containing a URL.
 				await message.delete()
 		elif 'chatwarn' in action:
 			if 'delete' in action:
-				response = f':warning: Links with deceptive labels are prohibited :warning:'
+				response = ':warning: Links with deceptive labels are prohibited :warning:'
 			else:
-				response = f':warning: Message contains a deceptively labeled link! Click carefully. :warning:'
+				response = ':warning: Message contains a deceptively labeled link! Click carefully. :warning:'
 			await message.reply(response, mention_author=False)
 			if 'delete' in action:
 				await message.delete()
 		elif action == 'delete':
-			mod_text += f'\n\nDeleting message'
+			mod_text += '\n\nDeleting message'
 			bm = BotMessage(message.guild, mod_text, BotMessage.TYPE_INFO, suppress_embeds=True)
 			await self.post_message(bm)
 			await message.delete()
 		elif action == 'kick':
-			mod_text += f'\n\nUser kicked'
+			mod_text += '\n\nUser kicked'
 			bm = BotMessage(message.guild, mod_text, BotMessage.TYPE_MOD_WARNING, suppress_embeds=True)
 			await self.post_message(bm)
 			await message.delete()
 			await message.author.kick(
-				reason=f'Rocketbot: User posted a deceptive link')
+				reason='Rocketbot: User posted a deceptive link')
 		elif action == 'ban':
-			mod_text += f'\n\nUser banned'
+			mod_text += '\n\nUser banned'
 			bm = BotMessage(message.guild, mod_text, BotMessage.TYPE_MOD_WARNING, suppress_embeds=True)
 			await self.post_message(bm)
 			await message.author.ban(
-				reason=f'Rocketbot: User posted a deceptive link',
+				reason='Rocketbot: User posted a deceptive link',
 				delete_message_days=1)
 
 	def contains_deceptive_links(self, content: str) -> bool:

rocketbot/cogs/usernamecog.py

 """
 from typing import Optional
 
-from discord import Guild, Member, Permissions, Interaction
+from discord import Guild, Interaction, Member
 from discord.app_commands import Group
 from discord.ext.commands import Cog
 

rocketbot/cogsetting.py

 """
 A guild configuration setting available for editing via bot commands.
 """
+
 from datetime import timedelta
-from typing import Any, Optional, Type, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Type, Union
 
 from discord import Interaction, Permissions
 from discord.app_commands import Range, Transform, describe
-from discord.app_commands.commands import Command, Group, CommandCallback, rename
+from discord.app_commands.commands import Command, CommandCallback, Group, rename
 from discord.ext.commands import Bot
 
 from config import CONFIG
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log, TimeDeltaTransformer, MOD_PERMISSIONS, dump_stacktrace, str_from_timedelta
+from rocketbot.utils import (
+	MOD_PERMISSIONS,
+	TimeDeltaTransformer,
+	bot_log,
+	dump_stacktrace,
+	str_from_timedelta,
+)
 
+if TYPE_CHECKING:
+	from rocketbot.cogs.basecog import BaseCog
+else:
+	BaseCog = 'BaseCog'
 
 def describe_type(datatype: Type) -> str:
 	if datatype is int:
 			allowed_values = '`' + ('`, `'.join(self.enum_values)) + '`'
 			raise ValueError(f'`{self.name}` must be one of {allowed_values}')
 
-	def set_up(self, cog: 'BaseCog') -> None:
+	def set_up(self, cog: BaseCog) -> None:
 		"""
 		Sets up getter and setter commands for this setting. This should
 		usually only be called by BaseCog.
 			return 'true' if native_value else 'false'
 		return f'{native_value}'
 
-	def __make_getter_command(self, cog: 'BaseCog') -> Command:
+	def __make_getter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		setting_name = setting.name
 		if cog.config_prefix is not None:
 			value = setting.to_native_value(Storage.get_config_value(interaction.guild, key))
 			cog.log(interaction.guild, f'{interaction.user.name} used /get setting_name')
 			if value is None:
-				value = setting.to_native_value(cog.get_cog_default(setting.name))
+				value = setting.default_value
 				await interaction.response.send_message(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{CogSetting.native_value_to_str(value)}`',
 					ephemeral=True
 		)
 		return command
 
-	def __make_setter_command(self, cog: 'BaseCog') -> Command:
+	def __make_setter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		setting_name = setting.name
 		if cog.config_prefix is not None:
 			await cog.on_setting_updated(interaction.guild, setting)
 
 		setter: CommandCallback = setter_general
+		field_description: str = self.brief
 		if self.datatype is int:
 			if self.min_value is not None or self.max_value is not None:
 				r_min = self.min_value
 				r_max = self.max_value
-				@rename(new_value=self.name)
-				@describe(new_value=self.brief)
 				async def setter_range(interaction: Interaction, new_value: Range[int, r_min, r_max]) -> None:
 					await setter_general(interaction, new_value)
 				setter = setter_range
 			else:
-				@rename(new_value=self.name)
-				@describe(new_value=self.brief)
 				async def setter_int(interaction: Interaction, new_value: int) -> None:
 					await setter_general(interaction, new_value)
 				setter = setter_int
 		elif self.datatype is float:
-			@rename(new_value=self.name)
-			@describe(new_value=self.brief)
 			async def setter_float(interaction: Interaction, new_value: float) -> None:
 				await setter_general(interaction, new_value)
 			setter = setter_float
 		elif self.datatype is timedelta:
-			@rename(new_value=self.name)
-			@describe(new_value=f'{self.brief} (e.g. 30s, 5m, 1h30s, 7d)')
+			field_description += ' (e.g. 30s, 5m, 1h30s, 7d)'
 			async def setter_timedelta(interaction: Interaction, new_value: Transform[timedelta, TimeDeltaTransformer]) -> None:
 				await setter_general(interaction, new_value)
 			setter = setter_timedelta
 		elif getattr(self.datatype, '__origin__', None) == Literal:
 			dt = self.datatype
-			@rename(new_value=self.name)
-			@describe(new_value=self.brief)
 			async def setter_enum(interaction: Interaction, new_value: dt) -> None:
 				await setter_general(interaction, new_value)
 			setter = setter_enum
 			if self.enum_values is not None:
 				raise ValueError('Type for a setting with enum values should be typing.Literal')
 			else:
-				@rename(new_value=self.name)
-				@describe(new_value=self.brief)
 				async def setter_str(interaction: Interaction, new_value: str) -> None:
 					await setter_general(interaction, new_value)
 				setter = setter_str
 		elif self.datatype is bool:
-			@rename(new_value=self.name)
-			@describe(new_value=self.brief)
 			async def setter_bool(interaction: Interaction, new_value: bool) -> None:
 				await setter_general(interaction, new_value)
 			setter = setter_bool
 		elif self.datatype is not None:
 			raise ValueError(f'Invalid type {self.datatype}')
+		setter = describe(new_value=field_description)(rename(new_value=self.name)(setter))
 
 		bot_log(None, cog.__class__, f"Creating command: /set {setting_name} <{describe_type(self.datatype)}>")
 		command = Command(
 		)
 		return command
 
-	def __make_enable_command(self, cog: 'BaseCog') -> Command:
+	def __make_enable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		async def enabler(interaction: Interaction) -> None:
 			key = f'{cog.__class__.__name__}.{setting.name}'
 		)
 		return command
 
-	def __make_disable_command(self, cog: 'BaseCog') -> Command:
+	def __make_disable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		async def disabler(interaction: Interaction) -> None:
 			key = f'{cog.__class__.__name__}.{setting.name}'
 	__disable_group: Group
 
 	@classmethod
-	def set_up_all(cls, cog: 'BaseCog', bot: Bot, settings: list['CogSetting']) -> None:
+	def set_up_all(cls, cog: BaseCog, bot: Bot, settings: list['CogSetting']) -> None:
 		"""
 		Sets up editing commands for a list of CogSettings and adds them to a
 		cog. If the cog has a command Group, commands will be added to it.
 
 	@classmethod
 	def __set_up_base_commands(cls, bot: Bot) -> None:
-		if getattr(cls, f'_CogSetting__set_group', None) is not None:
+		if getattr(cls, '_CogSetting__set_group', None) is not None:
 			return
 		cls.__set_group = Group(
 			name='set',
 		bot.tree.add_command(cls.__enable_group)
 		bot.tree.add_command(cls.__disable_group)
 
-		from rocketbot.cogs.basecog import BaseCog
 		async def show_all(interaction: Interaction) -> None:
+			from rocketbot.cogs.basecog import BaseCog
 			try:
 				bot_log(interaction.guild, None, f'{interaction.user.name} used /get all')
 				guild = interaction.guild
 					for setting in sorted(bcog.settings, key=lambda s: (s.name != 'enabled', s.name)):
 						key = f'{bcog.__class__.__name__}.{setting.name}'
 						value = setting.to_native_value(Storage.get_config_value(guild, key))
-						deflt = setting.to_native_value(bcog.get_cog_default(setting.name))
+						deflt = setting.default_value
 						if setting.name == 'enabled':
-							text += f'\n- Module is '
+							text += '\n- Module is '
 							if value is not None:
 								text += '**' + ('enabled' if value else 'disabled') + '**'
 							else:

rocketbot/collections.py

 """
 
 from abc import ABCMeta, abstractmethod
-from typing import Callable, Generic, TypeVar, Optional
+from typing import Callable, Generic, Optional, TypeVar
 
 # Abstract collections
 

rocketbot/pattern.py

 import re
 from abc import ABCMeta, abstractmethod
 from datetime import datetime, timezone
-from typing import Any, Union, Literal
+from typing import Any, Literal, Union
 
-from discord import Message, utils as discordutils
+from discord import Message
+from discord import utils as discordutils
 from discord.ext.commands import Context
 
-from rocketbot.utils import is_user_id, str_from_quoted_str, timedelta_from_str, \
-	user_id_from_mention
+from rocketbot.utils import (
+	is_user_id,
+	str_from_quoted_str,
+	timedelta_from_str,
+	user_id_from_mention,
+)
 
 PatternField = Literal['content.markdown', 'content', 'content.plain', 'author', 'author.id', 'author.joinage', 'author.name', 'lastmatched']
 PatternComparisonOperator = Literal['==', '!=', '<', '>', '<=', '>=', 'contains', '!contains', 'matches', '!matches', 'containsword', '!containsword']

rocketbot/storage.py

 Handles storage of persisted and non-persisted data for the bot.
 """
 import json
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timedelta, timezone
 from os.path import exists
 from typing import Any, Optional
+
 from discord import Guild
 
 from config import CONFIG

rocketbot/utils.py

 from typing import Any, Optional, Type, Union
 
 import discord
-from discord import Guild, Permissions
-from discord.ext.commands import Cog
+from discord import Guild, Interaction, Permissions
+from discord.app_commands import Transformer
+from discord.ext.commands import BadArgument, Cog
+
 
 def dump_stacktrace(e: BaseException) -> None:
 	print(e, file=sys.stderr)
 
 MOD_PERMISSIONS: Permissions = Permissions(Permissions.manage_messages.flag)
 
-from discord import Interaction
-from discord.app_commands import Transformer
-from discord.ext.commands import BadArgument
-
 class TimeDeltaTransformer(Transformer):
 	async def transform(self, interaction: Interaction, value: Any) -> timedelta:
 		try: