Slash commands registering but not receiving callbacks

rocketbot/bot.py

@@ -5,7 +5,10 @@ from discord import Intents
 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):
 	"""
@@ -16,11 +19,7 @@ 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:
@@ -43,6 +42,19 @@ class Rocketbot(commands.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

@@ -2,20 +2,21 @@
 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
@@ -107,8 +108,8 @@ class BaseCog(commands.Cog):
 		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

@@ -53,12 +53,6 @@ class GeneralCog(BaseCog, name='General'):
 		"""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

@@ -3,6 +3,8 @@ Cog for detecting URLs posted by new users.
 """
 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
@@ -30,7 +32,7 @@ class URLSpamCog(BaseCog, name='URL Spam'):
 	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'})
@@ -44,7 +46,7 @@ class URLSpamCog(BaseCog, name='URL Spam'):
 				'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

@@ -1,16 +1,17 @@
 """
 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:
 # 	"""
@@ -21,7 +22,11 @@ from rocketbot.storage import Storage
 # 	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
@@ -99,22 +104,23 @@ class CogSetting:
 		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
@@ -124,11 +130,14 @@ class CogSetting:
 					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
 
@@ -136,8 +145,9 @@ class CogSetting:
 		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:
@@ -146,41 +156,65 @@ class CogSetting:
 					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,
 		)
@@ -192,19 +226,23 @@ new_value: {type_str}
 
 	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,
 		)
@@ -214,19 +252,23 @@ new_value: {type_str}
 
 	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,
 		)
@@ -248,8 +290,12 @@ new_value: {type_str}
 		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:
@@ -259,22 +305,22 @@ new_value: {type_str}
 		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

@@ -11,7 +11,7 @@ import discord
 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__)