Slash commands registering but not receiving callbacks

rocketbot/bot.py

 from discord.ext import commands
 
 from config import CONFIG
-from rocketbot.utils import bot_log
+from rocketbot.cogs.basecog import BaseCog
+from rocketbot.cogsetting import CogSetting
+from rocketbot.utils import bot_log, dump_stacktrace
+
 
 class Rocketbot(commands.Bot):
 	"""
 
 	async def on_command_error(self, context: commands.Context, exception: BaseException) -> None:
 		bot_log(None, None, f'Command error')
-		ex = exception
-		while ex is not None:
-			print(f'Caused by {ex}')
-			traceback.print_exception(type(ex), ex, ex.__traceback__)
-			ex = ex.__cause__ if ex.__cause__ != ex else None
+		dump_stacktrace(exception)
 		if context.guild is None or \
 				context.message.channel is None or \
 				context.message.author.bot:
 			f'	event kwargs: {kwargs}' + \
 			traceback.format_exc())
 
+	async def on_ready(self):
+		for cog in self.cogs.values():
+			if isinstance(cog, BaseCog):
+				bcog: BaseCog = cog
+				if len(bcog.settings) > 0:
+					CogSetting.set_up_all(bcog, self, bcog.settings)
+		try:
+			synced_commands = await self.tree.sync()
+			for command in synced_commands:
+				bot_log(None, None, f'Synced command: /{command.name}')
+		except Exception as e:
+			dump_stacktrace(e)
+
 # Current active bot instance
 rocketbot: Optional[Rocketbot] = None
 

rocketbot/cogs/basecog.py

 Base cog class and helper classes.
 """
 from datetime import datetime, timedelta, timezone
-from typing import Optional
+from typing import Optional, ForwardRef
 
 from discord import Guild, Member, Message, RawReactionActionEvent, TextChannel
 from discord.abc import GuildChannel
 from discord.ext import commands
 
 from config import CONFIG
-from rocketbot.bot import Rocketbot
 from rocketbot.botmessage import BotMessage, BotMessageReaction
 from rocketbot.cogsetting import CogSetting
 from rocketbot.collections import AgeBoundDict
 from rocketbot.storage import Storage
 from rocketbot.utils import bot_log
 
+Rocketbot = ForwardRef('rocketbot.bot.Rocketbot')
+
 class WarningContext:
 	def __init__(self, member: Member, warn_time: datetime):
 		self.member = member
 		key = f'{cls.__name__}.{setting.name}'
 		Storage.set_config_value(guild, key, new_value)
 
-	@commands.Cog.listener()
-	async def on_ready(self):
+	# @commands.Cog.listener()
+	async def __on_ready(self):
 		"""Event listener"""
 		if not self.are_settings_setup:
 			self.are_settings_setup = True

rocketbot/cogs/generalcog.py

 		"""Event handler"""
 		self.log(None, 'Bot done initializing')
 		self.is_ready = True
-		try:
-			synced_commands = await self.bot.tree.sync()
-			for command in synced_commands:
-				self.log(None, f'Synced command: {command.name}')
-		except Exception as e:
-			dump_stacktrace(e)
 		if self.is_first_ready:
 			print('----------------------------------------------------------')
 			self.is_first_ready = False

rocketbot/cogs/urlspamcog.py

 """
 import re
 from datetime import timedelta
+from typing import Literal
+
 from discord import Member, Message, utils as discordutils
 from discord.ext import commands
 from discord.utils import escape_markdown
 	SETTING_ENABLED = CogSetting('enabled', bool,
 			brief='URL spam detection',
 			description='Whether URLs posted soon after joining are flagged.')
-	SETTING_ACTION = CogSetting('action', str,
+	SETTING_ACTION = CogSetting('action', Literal['nothing', 'modwarn', 'delete', 'kick', 'ban'],
 			brief='action to take on spam',
 			description='The action to take on detected URL spam.',
 			enum_values={'nothing', 'modwarn', 'delete', 'kick', 'ban'})
 				'disables URL spam detection.',
 			usage='<seconds:int>',
 			min_value=0)
-	SETTING_DECEPTIVE_ACTION = CogSetting('deceptiveaction', str,
+	SETTING_DECEPTIVE_ACTION = CogSetting('deceptiveaction', Literal['nothing', 'modwarn', 'modwarndelete', 'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'],
 			brief='action to take on deceptive link markdown',
 			description='The action to take on chat messages with links ' + \
 				'where the text looks like a different URL than the actual link.',

rocketbot/cogsetting.py

 """
 A guild configuration setting available for editing via bot commands.
 """
-from __future__ import annotations
-from typing import Any, Optional, Type
+import inspect
+from typing import Any, Optional, Type, TypeVar, Coroutine, Literal
 
-from discord import Interaction, Permissions
-from discord.app_commands.commands import Command, Group
+from discord import Interaction, Permissions, permissions
+from discord.app_commands import Range, guild_only, default_permissions
+from discord.app_commands.commands import Command, Group, CommandCallback
 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 bot_log
 
 # def _fix_command(command: Command) -> None:
 # 	"""
 # 	del params['context']
 # 	command.params = params
 
+BaseCog = TypeVar('BaseCog', bound='rocketbot.cogs.BaseCog')
+
 class CogSetting:
+	permissions: Permissions = Permissions(Permissions.manage_messages.flag)
+
 	"""
 	Describes a configuration setting for a guild that can be edited by the
 	mods of those guilds. BaseCog can generate "get" and "set" commands (or
 		usually only be called by BaseCog.
 		"""
 		if self.name in ('enabled', 'is_enabled'):
-			bot.tree.add_command(self.__make_enable_command(cog))
-			bot.tree.add_command(self.__make_disable_command(cog))
+			self.__enable_group.add_command(self.__make_enable_command(cog))
+			self.__disable_group.add_command(self.__make_disable_command(cog))
 		else:
-			bot.tree.add_command(self.__make_getter_command(cog))
-			bot.tree.add_command(self.__make_setter_command(cog))
+			self.__get_group.add_command(self.__make_getter_command(cog))
+			self.__set_group.add_command(self.__make_setter_command(cog))
 
 	def __make_getter_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
 		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}'
+			setting_name = f'{cog.config_prefix}_{setting_name}'
+		async def getter(self, interaction: Interaction) -> None:
+			print(f"invoking getter for {setting_name}")
+			key = f'{self.__class__.__name__}.{setting.name}'
 			value = Storage.get_config_value(interaction.guild, key)
 			if value is None:
-				value = cog0.get_cog_default(setting.name)
+				value = self.get_cog_default(setting.name)
 				await interaction.response.send_message(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{value}`',
 					ephemeral=True
 					f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{value}`',
 					ephemeral=True
 				)
+		setattr(cog.__class__, f'_cmd_get_{setting.name}', getter)
+		getter.__qualname__ = f'{self.__class__.__name__}._cmd_get_{setting.name}'
+		bot_log(None, cog.__class__, f"Creating /get {setting_name}")
 		command = Command(
 			name=setting_name,
-			description=setting.description,
+			description=f'Shows value of {setting_name}',
 			callback=getter,
-			parent=CogSetting.__get_group
+			parent=CogSetting.__get_group,
 		)
 		return command
 
 		setting: CogSetting = self
 		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:
+			setting_name = f'{cog.config_prefix}_{setting_name}'
+		async def setter_general(self, interaction: Interaction, new_value) -> None:
+			print(f"invoking setter for {setting_name} with value {new_value}")
 			try:
 				setting.validate_value(new_value)
 			except ValueError as ve:
 					ephemeral=True
 				)
 				return
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+			key = f'{self.__class__.__name__}.{setting.name}'
 			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}`',
 				ephemeral=True
 			)
-			await cog0.on_setting_updated(interaction.guild, setting)
-			cog0.log(interaction.guild, f'{interaction.message.author.name} set {key} to {new_value}')
+			await self.on_setting_updated(interaction.guild, setting)
+			self.log(interaction.guild, f'{interaction.message.author.name} set {key} to {new_value}')
 
 		type_str: str = 'any'
+		setter: CommandCallback = setter_general
 		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}]'
+				r_min = self.min_value
+				r_max = self.max_value
+				async def setter_range(self, interaction: Interaction, new_value: Range[int, r_min, r_max]) -> None:
+					await self.setter_general(interaction, new_value)
+				setter = setter_range
 			else:
 				type_str = 'int'
-		elif setting.datatype == str:
+				async def setter_int(self, interaction: Interaction, new_value: int) -> None:
+					await self.setter_general(interaction, new_value)
+				setter = setter_int
+		elif self.datatype == float:
+			type_str = 'float'
+			async def setter_float(self, interaction: Interaction, new_value: float) -> None:
+				await self.setter_general(interaction, new_value)
+			setter = setter_float
+		elif getattr(self.datatype, '__origin__', None) == Literal:
+			value_list = '"' + '", "'.join(self.enum_values) + '"'
+			type_str = f'typing.Literal[{value_list}]'
+			values = self.enum_values
+			dt = self.datatype
+			async def setter_enum(self, interaction: Interaction, new_value: dt) -> None:
+				await self.setter_general(interaction, new_value)
+
+			setter = setter_enum
+		elif self.datatype == str:
 			if self.enum_values is not None:
-				value_list = '"' + '", "'.join(self.enum_values) + '"'
-				type_str = f'typing.Literal[{value_list}]'
+				raise ValueError('Type for a setting with enum values should be typing.Literal')
 			else:
 				type_str = 'str'
+				async def setter_str(self, interaction: Interaction, new_value: str) -> None:
+					await self.setter_general(interaction, new_value)
+				setter = setter_str
 		elif setting.datatype == bool:
-			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}
-"""
+			type_str = f'bool'
+			async def setter_bool(self, interaction: Interaction, new_value: bool) -> None:
+				await self.setter_general(interaction, new_value)
+			setter = setter_bool
+		elif setting.datatype is not None:
+			raise ValueError(f'Invalid type {self.datatype}')
+		setattr(cog.__class__, f'_cmd_set_{setting.name}', setter)
+		setter.__qualname__ = f'{cog.__class__.__name__}._cmd_set_{setting.name}'
+		bot_log(None, cog.__class__, f"Creating /set {setting_name} {type_str}")
 		command = Command(
-			name=f'{setting.name}',
-			description=setting.description,
+			name=setting_name,
+			description=f'Sets value of {setting_name}',
 			callback=setter,
 			parent=CogSetting.__set_group,
 		)
 
 	def __make_enable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def enabler(cog0: BaseCog, interaction: Interaction) -> None:
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+		async def enabler(self, interaction: Interaction) -> None:
+			print(f"invoking enable for {self.config_prefix}")
+			key = f'{self.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, True)
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} enabled.',
 				ephemeral=True
 			)
-			await cog0.on_setting_updated(interaction.guild, setting)
-			cog0.log(interaction.guild, f'{interaction.message.author.name} enabled {cog0.__class__.__name__}')
+			await self.on_setting_updated(interaction.guild, setting)
+			self.log(interaction.guild, f'{interaction.message.author.name} enabled {self.__class__.__name__}')
+		setattr(cog.__class__, f'_cmd_enable', enabler)
+		enabler.__qualname__ = f'{cog.__class__.__name__}._cmd_enable'
+		bot_log(None, cog.__class__, f"Creating /enable {cog.config_prefix}")
 
 		command = Command(
 			name=cog.config_prefix,
-			description=setting.description,
+			description=f'Enables {cog.config_prefix} functionality',
 			callback=enabler,
 			parent=CogSetting.__enable_group,
 		)
 
 	def __make_disable_command(self, cog: BaseCog) -> Command:
 		setting: CogSetting = self
-		async def disabler(cog0: BaseCog, interaction: Interaction) -> None:
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+		async def disabler(self, interaction: Interaction) -> None:
+			print(f"invoking disable for {self.config_prefix}")
+			key = f'{self.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, False)
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} disabled.',
 				ephemeral=True
 			)
-			await cog0.on_setting_updated(interaction.guild, setting)
-			cog0.log(interaction.guild, f'{interaction.message.author.name} disabled {cog0.__class__.__name__}')
+			await self.on_setting_updated(interaction.guild, setting)
+			self.log(interaction.guild, f'{interaction.message.author.name} disabled {self.__class__.__name__}')
+		setattr(cog.__class__, f'_cmd_disable', disabler)
+		disabler.__qualname__ = f'{cog.__class__.__name__}._cmd_disable'
+		bot_log(None, cog.__class__, f"Creating /disable {cog.config_prefix}")
 
 		command = Command(
 			name=cog.config_prefix,
-			description=setting.description,
+			description=f'Disables {cog.config_prefix} functionality',
 			callback=disabler,
 			parent=CogSetting.__disable_group,
 		)
 		Otherwise, they will be added at the top level.
 		"""
 		cls.__set_up_base_commands(bot)
+		if len(settings) == 0:
+			return
+		bot_log(None, cog.__class__, f"Setting up slash commands for {cog.__class__.__name__}")
 		for setting in settings:
 			setting.set_up(cog, bot)
+		bot_log(None, cog.__class__, f"Done setting up slash commands for {cog.__class__.__name__}")
 
 	@classmethod
 	def __set_up_base_commands(cls, bot: Bot) -> None:
 		cls.__set_group = Group(
 			name='set',
 			description='Sets a bot configuration value for this guild',
-			default_permissions=Permissions.manage_messages
+			default_permissions=cls.permissions
 		)
 		cls.__get_group = Group(
 			name='get',
 			description='Shows a configured bot value for this guild',
-			default_permissions=Permissions.manage_messages
+			default_permissions=cls.permissions
 		)
 		cls.__enable_group = Group(
 			name='enable',
 			description='Enables a set of bot functionality for this guild',
-			default_permissions=Permissions.manage_messages
+			default_permissions=cls.permissions
 		)
 		cls.__disable_group = Group(
 			name='disable',
 			description='Disables a set of bot functionality for this guild',
-			default_permissions=Permissions.manage_messages
+			default_permissions=cls.permissions
 		)
 		bot.tree.add_command(cls.__set_group)
 		bot.tree.add_command(cls.__get_group)

rocketbot/utils.py

 from discord import Guild
 from discord.ext.commands import Cog
 
-def dump_stacktrace(e: Exception) -> None:
+def dump_stacktrace(e: BaseException) -> None:
 	print(e, file=sys.stderr)
 	traceback.print_exception(type(e), e, e.__traceback__)