Prettier startup logs. Removing command prefix references.

config.sample.py

 
 	# Client token obtained from the Discord application dashboard. See setup documentation.
 	'client_token': '<REQUIRED>',
-    # Bot commands will be invoked by posting a message with this prefix.
-	'command_prefix': '$rb_',
     # Path to a directory where guild-specific preferences will be stored.
     # Each guild's settings will be saved as a JSON file. Path should end with a slash.
 	'config_path': 'config/',

rocketbot/bot.py

 	"""
 	Bot subclass
 	"""
-	def __init__(self, command_prefix, **kwargs):
-		super().__init__(command_prefix, **kwargs)
+	def __init__(self, **kwargs):
+		# Bot requires command_prefix, even though we're only using slash commands,
+		# not commands in message content. Giving an unlikely prefix of private-use
+		# Unicode characters. This isn't a security thing, just avoiding showing a
+		# "command not found" error if someone happens to start a message with
+		# something more common.
+		super().__init__(command_prefix='\uED1E\uEA75\uF00D', **kwargs)
 		self.__commands_set_up = False
+		self.__first_ready = True
 
 	async def on_command_error(self, context: commands.Context, exception: BaseException) -> None:
 		bot_log(None, None, f'Command error')
 			traceback.format_exc())
 
 	async def on_ready(self):
-		if not self.__commands_set_up:
-			await self.__set_up_commands()
-		bot_log(None, None, 'Bot done initializing')
-		print('----------------------------------------------------------')
+		if self.__first_ready:
+			self.__first_ready = False
+			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.")
+			print('----------------------------------------------------------')
 
 	async def __set_up_commands(self):
 		if self.__commands_set_up:
 		return
 	bot_log(None, None, 'Creating bot...')
 	intents = Intents.default()
-	intents.messages = True  # pylint: disable=assigning-non-slot
-	intents.message_content = True  # pylint: disable=assigning-non-slot
-	intents.members = True  # pylint: disable=assigning-non-slot
+	intents.messages = True
+	intents.message_content = True
+	intents.members = True
 	intents.presences = True
-	rocketbot = Rocketbot(command_prefix=CONFIG['command_prefix'], intents=intents)
+	rocketbot = Rocketbot(intents=intents)
 __create_bot()
 
 from rocketbot.cogs.autokickcog import AutoKickCog
 
 async def start_bot():
 	bot_log(None, None, 'Bot initializing...')
-	bot_log(None, None, f"Type {CONFIG['command_prefix']}help in Discord for available commands.")
 
 	# Core
 	await rocketbot.add_cog(GeneralCog(rocketbot))

rocketbot/cogs/autokickcog.py

 		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: `{CONFIG["command_prefix"]}autokick disable`.'
-		ban_help = f'To configure ban threshold: `{CONFIG["command_prefix"]}autokick ' + \
-			'setbancount #` (0 to disable).'
+		disable_help = f'To disable this feature: `/disable autokick`.'
+		ban_help = f'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/helpcog.py

 
 		cmds = self.all_commands()
 		for cmd in cmds:
-			key = f'cmd:{cmd.name}'
-			self.obj_index[key] = cmd
+			self.obj_index[f'cmd:{cmd.name}'] = cmd
+			self.obj_index[f'/{cmd.name}'] = cmd
 			add_text_to_index(cmd, cmd.name)
 			if cmd.description:
 				add_text_to_index(cmd, cmd.description)
 			if isinstance(cmd, Group):
 				for subcmd in cmd.commands:
-					key = f'subcmd:{cmd.name}.{subcmd.name}'
-					self.obj_index[key] = subcmd
+					self.obj_index[f'subcmd:{cmd.name}.{subcmd.name}'] = subcmd
+					self.obj_index[f'/{cmd.name} {subcmd.name}'] = subcmd
 					add_text_to_index(subcmd, cmd.name)
 					add_text_to_index(subcmd, subcmd.name)
 					if subcmd.description:

rocketbot/cogsetting.py

 A guild configuration setting available for editing via bot commands.
 """
 from datetime import timedelta
-from typing import Any, Optional, Type, Literal
+from typing import Any, Optional, Type, Literal, Union
 
 from discord import Interaction, Permissions
 from discord.app_commands import Range, Transform, describe
 from rocketbot.utils import bot_log, TimeDeltaTransformer, MOD_PERMISSIONS, dump_stacktrace, str_from_timedelta
 
 
+def describe_type(datatype: Type) -> str:
+	if datatype is int:
+		return 'integer'
+	if datatype is float:
+		return 'float'
+	if datatype is str:
+		return 'string'
+	if datatype is bool:
+		return 'boolean'
+	if datatype is timedelta:
+		return 'timespan'
+	if getattr(datatype, '__origin__', None) is Union:
+		return '|'.join([ describe_type(a) for a in datatype.__args__ ])
+	if getattr(datatype, '__origin__', None) is Literal:
+		return '"' + ('"|"'.join(datatype.__args__)) + '"'
+	return datatype.__class__.__name__
+
 class CogSetting:
 	"""
 	Describes a configuration setting for a guild that can be edited by the
 					ephemeral=True
 				)
 
-		bot_log(None, cog.__class__, f"Creating /get {setting_name}")
+		bot_log(None, cog.__class__, f"Creating command: /get {setting_name}")
 		command = Command(
 			name=setting_name,
 			description=f'Shows {self.brief}.',
 		elif self.datatype is not None:
 			raise ValueError(f'Invalid type {self.datatype}')
 
-		bot_log(None, cog.__class__, f"Creating /set {setting_name} {self.datatype}")
+		bot_log(None, cog.__class__, f"Creating command: /set {setting_name} <{describe_type(self.datatype)}>")
 		command = Command(
 			name=setting_name,
 			description=f'Sets {self.brief}.',
 			await cog.on_setting_updated(interaction.guild, setting)
 			cog.log(interaction.guild, f'{interaction.user.name} enabled {cog.__class__.__name__}')
 
-		bot_log(None, cog.__class__, f"Creating /enable {cog.config_prefix}")
+		bot_log(None, cog.__class__, f"Creating command: /enable {cog.config_prefix}")
 		command = Command(
 			name=cog.config_prefix,
 			description=f'Enables {cog.qualified_name} functionality.',
 			await cog.on_setting_updated(interaction.guild, setting)
 			cog.log(interaction.guild, f'{interaction.user.name} disabled {cog.__class__.__name__}')
 
-		bot_log(None, cog.__class__, f"Creating /disable {cog.config_prefix}")
+		bot_log(None, cog.__class__, f"Creating command: /disable {cog.config_prefix}")
 		command = Command(
 			name=cog.config_prefix,
 			description=f'Disables {cog.config_prefix} functionality',
 		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_log(None, cog.__class__, f"Done setting up slash commands for {cog.__class__.__name__}")
 
 	@classmethod
 	def __set_up_base_commands(cls, bot: Bot) -> None: