Very WIP for converting config settings to slash commands

rocketbot/cogs/autokickcog.py

 	STATE_KEY_RECENT_KICKS = "AutoKickCog.recent_joins"
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'autokick')
 		self.add_setting(AutoKickCog.SETTING_ENABLED)
 		self.add_setting(AutoKickCog.SETTING_BAN_COUNT)
 		self.add_setting(AutoKickCog.SETTING_OFFLINE_ONLY)

rocketbot/cogs/basecog.py

 	Superclass for all Rocketbot cogs. Provides lots of conveniences for
 	common tasks.
 	"""
-	def __init__(self, bot):
+	def __init__(self, bot: Rocketbot, config_prefix: Optional[str]):
+		"""
+		Parameters
+		----------
+		bot: Rocketbot
+		config_prefix: str
+		    Prefix to show on variables in /set and /get commands to namespace
+		    configuration variables. E.g. if config_prefix is "foo", a config
+		    variable named "bar" in that cog will show as "foo.bar". If None,
+		    config variable acts as a top-level variable with no prefix.
+		"""
 		self.bot: Rocketbot = bot
-		self.are_settings_setup = False
-		self.settings = []
+		self.are_settings_setup: bool = False
+		self.settings: list[CogSetting] = []
+		self.config_prefix: Optional[str] = config_prefix
 
 	# Config
 

rocketbot/cogs/configcog.py

 """
 from discord import Guild, TextChannel
 from discord.ext import commands
+from discord.ext.commands import Bot
 
 from config import CONFIG
 from rocketbot.storage import ConfigKey, Storage
 	"""
 	Cog for handling general bot configuration.
 	"""
+
+	def __init__(self, bot: Bot) -> None:
+		super().__init__(bot, 'config')
+
 	@commands.group(
 		brief='Manages general bot configuration'
 	)

rocketbot/cogs/crosspostcog.py

 	STATE_KEY_SPAM_CONTEXT = "CrossPostCog.spam_context"
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'crosspost')
 		self.add_setting(CrossPostCog.SETTING_ENABLED)
 		self.add_setting(CrossPostCog.SETTING_WARN_COUNT)
 		self.add_setting(CrossPostCog.SETTING_DUPE_WARN_COUNT)

rocketbot/cogs/generalcog.py

 from discord.ext import commands
 
 from config import CONFIG
+from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage
 from rocketbot.utils import timedelta_from_str, describe_timedelta, dump_stacktrace
 from rocketbot.storage import ConfigKey, Storage
 	Cog for handling high-level bot functionality and commands. Should be the
 	first cog added to the bot.
 	"""
-	def __init__(self, bot: commands.Bot):
-		super().__init__(bot)
+	def __init__(self, bot: Rocketbot):
+		super().__init__(bot, None)
 		self.is_connected = False
 		self.is_ready = False
 		self.is_first_ready = True

rocketbot/cogs/joinagecog.py

 from discord.ext import commands
 
 from config import CONFIG
+from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from rocketbot.collections import AgeBoundList
 from rocketbot.storage import Storage
 
 	STATE_KEY_RECENT_JOINS = "JoinAgeCog.recent_joins"
 
-	def __init__(self, bot):
-		super().__init__(bot)
+	def __init__(self, bot: Rocketbot):
+		super().__init__(bot, 'joinage')
 		self.add_setting(JoinAgeCog.SETTING_ENABLED)
 		self.add_setting(JoinAgeCog.SETTING_JOIN_TIME)
 

rocketbot/cogs/joinraidcog.py

 	STATE_KEY_LAST_RAID = "JoinRaidCog.last_raid"
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'joinraid')
 		self.add_setting(JoinRaidCog.SETTING_ENABLED)
 		self.add_setting(JoinRaidCog.SETTING_JOIN_COUNT)
 		self.add_setting(JoinRaidCog.SETTING_JOIN_TIME)

rocketbot/cogs/logcog.py

 	STATE_EVENT_BUFFER = 'LoggingCog.eventBuffer'
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'logging')
 		self.add_setting(LoggingCog.SETTING_ENABLED)
 		self.flush_buffers.start()
 		self.buffered_guilds: set[Guild] = set()

rocketbot/cogs/patterncog.py

 from discord.ext import commands
 
 from config import CONFIG
+from rocketbot.bot import Rocketbot
 from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction
 from rocketbot.cogsetting import CogSetting
 from rocketbot.pattern import PatternCompiler, PatternDeprecationError, \
 
 	SETTING_PATTERNS = CogSetting('patterns', None)
 
+	def __init__(self, bot: Rocketbot):
+		super().__init__(bot, 'patterns')
+
 	def __get_patterns(self, guild: Guild) -> dict[str, PatternStatement]:
 		"""
 		Returns a name -> PatternStatement lookup for the guild.

rocketbot/cogs/urlspamcog.py

 				'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'})
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'urlspam')
 		self.add_setting(URLSpamCog.SETTING_ENABLED)
 		self.add_setting(URLSpamCog.SETTING_ACTION)
 		self.add_setting(URLSpamCog.SETTING_JOIN_AGE)

rocketbot/cogs/usernamecog.py

 	SETTING_PATTERNS = CogSetting('patterns', None)
 
 	def __init__(self, bot):
-		super().__init__(bot)
+		super().__init__(bot, 'username')
 		self.add_setting(UsernamePatternCog.SETTING_ENABLED)
 
 	def __get_patterns(self, guild: Guild) -> list[str]:

rocketbot/cogsetting.py

 """
 A guild configuration setting available for editing via bot commands.
 """
-from typing import Any, Callable, Coroutine, Optional, Type
+from __future__ import annotations
+from typing import Any, Optional, Type
 
-from discord.ext import commands
-from discord.ext.commands import Bot, Command, Context, Group, Cog
+from discord import Interaction, Permissions
+from discord.app_commands.commands import Command, Group
+from discord.ext.commands import Bot
 
 from config import CONFIG
+from rocketbot.cogs.basecog import BaseCog
 from rocketbot.storage import Storage
-from rocketbot.utils import first_command_group
 
-def _fix_command(command: Command) -> None:
-	"""
-	HACK: Fixes bug in discord.py 2.3.2 where it's requiring the user to
-	supply the context argument. This removes that argument from the list.
-	"""
-	params = command.params
-	del params['context']
-	command.params = params
+# def _fix_command(command: Command) -> None:
+# 	"""
+# 	HACK: Fixes bug in discord.py 2.3.2 where it's requiring the user to
+# 	supply the context argument. This removes that argument from the list.
+# 	"""
+# 	params = command.params
+# 	del params['context']
+# 	command.params = params
 
 class CogSetting:
 	"""
 			max_value: Optional[Any] = None,
 			enum_values: Optional[set[Any]] = None):
 		"""
-		Params:
-		- name         Setting identifier. Must follow variable naming
-		               conventions.
-		- datatype     Datatype of the setting. E.g. int, float, str
-		- brief        Description of the setting, starting with lower case.
-		               Will be inserted into phrases like "Sets <brief>" and
-					   "Gets <brief".
-		- description  Long-form description. Min, max, and enum values will be
-		               appended to the end, so does not need to include these.
-		- usage        Description of the value argument in a set command, e.g.
-		               "<maxcount:int>"
-		- min_value    Smallest allowable value. Must be of the same datatype as
-		               the value. None for no minimum.
-		- max_value    Largest allowable value. None for no maximum.
-		- enum_values  Set of allowed values. None if unconstrained.
+		Parameters
+		----------
+		name: str
+			Setting identifier. Must follow variable naming conventions.
+		datatype: Optional[Type]
+		    Datatype of the setting. E.g. int, float, str
+		brief: Optional[str]
+			Description of the setting, starting with lower case.
+			Will be inserted into phrases like "Sets <brief>" and
+			"Gets <brief".
+		description: Optional[str]
+		  	Long-form description. Min, max, and enum values will be
+		    appended to the end, so does not need to include these.
+		usage: Optional[str]
+		    Description of the value argument in a set command, e.g. "<maxcount:int>"
+		min_value: Optional[Any]
+		    Smallest allowable value. Must be of the same datatype as
+		    the value. None for no minimum.
+		max_value: Optional[Any]
+		    Largest allowable value. None for no maximum.
+		enum_values: Optional[set[Any]]
+		  	Set of allowed values. None if unconstrained.
 		"""
 		self.name: str = name
 		self.datatype: Type = datatype
 		if self.usage is None:
 			self.usage = f'<{self.name}>'
 
-	def validate_value(self, new_value) -> None:
+	def validate_value(self, new_value: Any) -> None:
 		"""
 		Checks if a value is legal for this setting. Raises a ValueError if not.
 		"""
 			allowed_values = '`' + ('`, `'.join(self.enum_values)) + '`'
 			raise ValueError(f'`{self.name}` must be one of {allowed_values}')
 
-	def set_up(self, cog: Cog, bot: Bot, group: Group) -> None:
+	def set_up(self, cog: BaseCog, bot: Bot) -> None:
 		"""
 		Sets up getter and setter commands for this setting. This should
 		usually only be called by BaseCog.
 		"""
 		if self.name in ('enabled', 'is_enabled'):
-			(group or bot).add_command(self.__make_enable_command(cog))
-			(group or bot).add_command(self.__make_disable_command(cog))
+			bot.tree.add_command(self.__make_enable_command(cog))
+			bot.tree.add_command(self.__make_disable_command(cog))
 		else:
-			(group or bot).add_command(self.__make_getter_command(cog))
-			(group or bot).add_command(self.__make_setter_command(cog))
+			bot.tree.add_command(self.__make_getter_command(cog))
+			bot.tree.add_command(self.__make_setter_command(cog))
 
-	def __make_getter_command(self, cog: Cog) -> Command:
+	def __make_getter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def getter(cog0: Cog, context: Context) -> None:
-			setting_name = setting.name
-			if isinstance(context.command.parent, Group):
-				setting_name = f'{context.command.parent.name}.{setting_name}'
+		setting_name = setting.name
+		if cog.config_prefix is not None:
+			setting_name = f'{cog.config_prefix}.{setting_name}'
+		async def getter(cog0: BaseCog, interaction: Interaction) -> None:
 			key = f'{cog0.__class__.__name__}.{setting.name}'
-			value = Storage.get_config_value(context.guild, key)
+			value = Storage.get_config_value(interaction.guild, key)
 			if value is None:
 				value = cog0.get_cog_default(setting.name)
-				await context.message.reply(
+				await interaction.response.send_message(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{value}`',
-					mention_author=False)
+					ephemeral=True
+				)
 			else:
-				await context.message.reply(
+				await interaction.response.send_message(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{value}`',
-					mention_author=False)
+					ephemeral=True
+				)
 		command = Command(
-			getter,
-			name=f'get{setting.name}',
-			brief=f'Shows {setting.brief}',
+			name=setting_name,
 			description=setting.description,
-			checks=[
-				commands.has_permissions(ban_members=True),
-				commands.guild_only(),
-			])
-		command.cog = cog
-		_fix_command(command)
+			callback=getter,
+			parent=CogSetting.__get_group
+		)
 		return command
 
-	def __make_setter_command(self, cog: Cog) -> Command:
+	def __make_setter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def setter_common(cog0: Cog, context: Context, new_value) -> None:
+		setting_name = setting.name
+		if cog.config_prefix is not None:
+			setting_name = f'{cog.config_prefix}.{setting_name}'
+		async def setter(cog0: BaseCog, interaction: Interaction, new_value) -> None:
 			try:
 				setting.validate_value(new_value)
 			except ValueError as ve:
-				await context.message.reply(
+				await interaction.response.send_message(
 					f'{CONFIG["failure_emoji"]} {ve}',
-					mention_author=False)
+					ephemeral=True
+				)
 				return
-			setting_name = setting.name
-			if isinstance(context.command.parent, Group):
-				setting_name = f'{context.command.parent.name}.{setting_name}'
 			key = f'{cog0.__class__.__name__}.{setting.name}'
-			Storage.set_config_value(context.guild, key, new_value)
-			await context.message.reply(
+			Storage.set_config_value(interaction.guild, key, new_value)
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} `{setting_name}` is now set to `{new_value}`',
-				mention_author=False)
-			await cog0.on_setting_updated(context.guild, setting)
-			cog0.log(context.guild, f'{context.author.name} set {key} to {new_value}')
-
-		async def setter_int(cog1, context, new_value: int):
-			await setter_common(cog1, context, new_value)
-		async def setter_float(cog2, context, new_value: float):
-			await setter_common(cog2, context, new_value)
-		async def setter_str(cog3, context, new_value: str):
-			await setter_common(cog3, context, new_value)
-		async def setter_bool(cog4, context, new_value: bool):
-			await setter_common(cog4, context, new_value)
-
-		setter: Callable[[Cog, Context, Any], Coroutine]
-		if setting.datatype == int:
-			setter = setter_int
-		elif setting.datatype == float:
-			setter = setter_float
+				ephemeral=True
+			)
+			await cog0.on_setting_updated(interaction.guild, setting)
+			cog0.log(interaction.guild, f'{interaction.message.author.name} set {key} to {new_value}')
+
+		type_str: str = 'any'
+		if self.datatype == int:
+			if self.min_value is not None or self.max_value is not None:
+				type_str = f'discord.app_commands.Range[int, {self.min_value}, {self.max_value}]'
+			else:
+				type_str = 'int'
 		elif setting.datatype == str:
-			setter = setter_str
+			if self.enum_values is not None:
+				value_list = '"' + '", "'.join(self.enum_values) + '"'
+				type_str = f'typing.Literal[{value_list}]'
+			else:
+				type_str = 'str'
 		elif setting.datatype == bool:
-			setter = setter_bool
-		else:
-			raise ValueError(f'Datatype {setting.datatype} unsupported')
+			type_str = f'typing.Literal["false", "true"]'
 
+		setter.__doc__ = f"""Sets {self.description}.
+
+Parameters
+----------
+cog: discord.ext.commands.Cog
+interaction: discord.Interaction
+new_value: {type_str}
+"""
 		command = Command(
-			setter,
-			name=f'set{setting.name}',
-			brief=f'Sets {setting.brief}',
+			name=f'{setting.name}',
 			description=setting.description,
-			usage=setting.usage,
-			checks=[
-				commands.has_permissions(ban_members=True),
-				commands.guild_only(),
-			])
+			callback=setter,
+			parent=CogSetting.__set_group,
+		)
 		# HACK: Passing `cog` in init gets ignored and set to `None` so set after.
 		# This ensures the callback is passed the cog as `self` argument.
-		command.cog = cog
-		_fix_command(command)
+		# command.cog = cog
+		# _fix_command(command)
 		return command
 
-	def __make_enable_command(self, cog: Cog) -> Command:
+	def __make_enable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def enabler(cog0: Cog, context: Context) -> None:
+		async def enabler(cog0: BaseCog, interaction: Interaction) -> None:
 			key = f'{cog0.__class__.__name__}.{setting.name}'
-			Storage.set_config_value(context.guild, key, True)
-			await context.message.reply(
+			Storage.set_config_value(interaction.guild, key, True)
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} enabled.',
-				mention_author=False)
-			await cog0.on_setting_updated(context.guild, setting)
-			cog0.log(context.guild, f'{context.author.name} enabled {cog0.__class__.__name__}')
+				ephemeral=True
+			)
+			await cog0.on_setting_updated(interaction.guild, setting)
+			cog0.log(interaction.guild, f'{interaction.message.author.name} enabled {cog0.__class__.__name__}')
 
 		command = Command(
-			enabler,
-			name='enable',
-			brief=f'Enables {setting.brief}',
+			name=cog.config_prefix,
 			description=setting.description,
-			checks=[
-				commands.has_permissions(ban_members=True),
-				commands.guild_only(),
-			])
-		command.cog = cog
-		_fix_command(command)
+			callback=enabler,
+			parent=CogSetting.__enable_group,
+		)
+		# command.cog = cog
+		# _fix_command(command)
 		return command
 
-	def __make_disable_command(self, cog: Cog) -> Command:
+	def __make_disable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def disabler(cog0: Cog, context: Context) -> None:
+		async def disabler(cog0: BaseCog, interaction: Interaction) -> None:
 			key = f'{cog0.__class__.__name__}.{setting.name}'
-			Storage.set_config_value(context.guild, key, False)
-			await context.message.reply(
+			Storage.set_config_value(interaction.guild, key, False)
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} disabled.',
-				mention_author=False)
-			await cog0.on_setting_updated(context.guild, setting)
-			cog0.log(context.guild, f'{context.author.name} disabled {cog0.__class__.__name__}')
+				ephemeral=True
+			)
+			await cog0.on_setting_updated(interaction.guild, setting)
+			cog0.log(interaction.guild, f'{interaction.message.author.name} disabled {cog0.__class__.__name__}')
 
 		command = Command(
-			disabler,
-			name='disable',
-			brief=f'Disables {setting.brief}',
+			name=cog.config_prefix,
 			description=setting.description,
-			checks=[
-				commands.has_permissions(ban_members=True),
-				commands.guild_only(),
-			])
-		command.cog = cog
-		_fix_command(command)
+			callback=disabler,
+			parent=CogSetting.__disable_group,
+		)
+		# command.cog = cog
+		# _fix_command(command)
 		return command
 
+	__has_set_up_base_commands: bool = False
+	__set_group: Group
+	__get_group: Group
+	__enable_group: Group
+	__disable_group: Group
+
 	@classmethod
-	def set_up_all(cls, cog: Cog, bot: Bot, settings: list) -> 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.
-		Otherwise they will be added at the top level.
+		Otherwise, they will be added at the top level.
 		"""
-		group: Group = first_command_group(cog)
+		cls.__set_up_base_commands(bot)
 		for setting in settings:
-			setting.set_up(cog, bot, group)
+			setting.set_up(cog, bot)
+
+	@classmethod
+	def __set_up_base_commands(cls, bot: Bot) -> None:
+		if cls.__has_set_up_base_commands:
+			return
+		cls.__has_set_up_base_commands = True
+		cls.__set_group = Group(
+			name='set',
+			description='Sets a bot configuration value for this guild',
+			default_permissions=Permissions.manage_messages
+		)
+		cls.__get_group = Group(
+			name='get',
+			description='Shows a configured bot value for this guild',
+			default_permissions=Permissions.manage_messages
+		)
+		cls.__enable_group = Group(
+			name='enable',
+			description='Enables a set of bot functionality for this guild',
+			default_permissions=Permissions.manage_messages
+		)
+		cls.__disable_group = Group(
+			name='disable',
+			description='Disables a set of bot functionality for this guild',
+			default_permissions=Permissions.manage_messages
+		)
+		bot.tree.add_command(cls.__set_group)
+		bot.tree.add_command(cls.__get_group)
+		bot.tree.add_command(cls.__enable_group)
+		bot.tree.add_command(cls.__disable_group)

rocketbot/utils.py

 from datetime import datetime, timedelta
 from typing import Any, Optional, Type, Union
 
+import discord
 from discord import Guild
-from discord.ext.commands import Cog, Group
+from discord.ext.commands import Cog
 
 def dump_stacktrace(e: Exception) -> None:
 	print(e, file=sys.stderr)
 		components = components[0:max_components]
 	return ' '.join(components)
 
-def first_command_group(cog: Cog) -> Optional[Group]:
+def _old_first_command_group(cog: Cog) -> Optional[discord.ext.commands.Group]:
 	"""Returns the first command Group found in a cog."""
 	for member_name in dir(cog):
 		member = getattr(cog, member_name)
-		if isinstance(member, Group):
+		if isinstance(member, discord.ext.commands.Group):
+			return member
+	return None
+
+def first_command_group(cog: Cog) -> Optional[discord.app_commands.Group]:
+	"""Returns the first slash command Group found in a cog."""
+	for member_name in dir(cog):
+		member = getattr(cog, member_name)
+		if isinstance(member, discord.app_commands.Group):
 			return member
 	return None