CogSetting accessors now ordinary functions not methods

rocketbot/cogsetting.py

 from rocketbot.utils import bot_log, TimeDeltaTransformer, MOD_PERMISSIONS, dump_stacktrace, str_from_timedelta
 
 
-# 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:
 	"""
 	Describes a configuration setting for a guild that can be edited by the
 		datatype: Optional[Type]
 		    Datatype of the setting. E.g. int, float, str
 		default_value: Any
-			Value to use in the absence of a specified value for the guild and
-			no value in config.py.
+			Value to use if a guild has not yet configured one.
 		brief: Optional[str]
 			Description of the setting, starting with lower case.
 			Will be inserted into phrases like "Sets <brief>" and
 			allowed_values = '`' + ('`, `'.join(self.enum_values)) + '`'
 			raise ValueError(f'`{self.name}` must be one of {allowed_values}')
 
-	def set_up(self, cog: 'BaseCog', bot: Bot) -> 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.
 			self.__set_group.add_command(self.__make_setter_command(cog))
 
 	def to_stored_value(self, native_value: Any) -> Any:
+		"""Converts a configuration value to a JSON-compatible datatype."""
 		if self.datatype is timedelta:
 			return native_value.total_seconds()
 		return native_value
 
 	def to_native_value(self, stored_value: Any) -> Any:
+		"""Converts the stored JSON-compatible datatype to its actual value."""
 		if self.datatype is timedelta and isinstance(stored_value, (int, float)):
 			return timedelta(seconds=stored_value)
 		return stored_value
 
-	def native_value_to_str(self, native_value: Any) -> str:
+	@staticmethod
+	def native_value_to_str(native_value: Any) -> str:
+		"""Formats a native configuration value to a user-presentable string."""
 		if native_value is None:
 			return '<no value>'
 		if isinstance(native_value, timedelta):
 		setting_name = setting.name
 		if cog.config_prefix is not None:
 			setting_name = f'{cog.config_prefix}_{setting_name}'
-		datatype = self.datatype
-		async def getter(cog0, interaction: Interaction) -> None:
-			print(f"invoking getter for {setting_name}")
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+		async def getter(interaction: Interaction) -> None:
+			key = f'{cog.__class__.__name__}.{setting.name}'
 			value = setting.to_native_value(Storage.get_config_value(interaction.guild, key))
 			if value is None:
-				value = setting.to_native_value(cog0.get_cog_default(setting.name))
+				value = setting.to_native_value(cog.get_cog_default(setting.name))
 				await interaction.response.send_message(
-					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{setting.native_value_to_str(value)}`',
+					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{CogSetting.native_value_to_str(value)}`',
 					ephemeral=True
 				)
 			else:
 				await interaction.response.send_message(
-					f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{setting.native_value_to_str(value)}`',
+					f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{CogSetting.native_value_to_str(value)}`',
 					ephemeral=True
 				)
 
-		# We have to do some surgery to make the getter function a proper method on the cog
-		# that discord.py will recognize and wire up correctly. Same for other accessors below.
-		setattr(cog.__class__, f'_cmd_get_{setting.name}', getter)  # add method to cog class
-		getter.__qualname__ = f'{self.__class__.__name__}._cmd_get_{setting.name}'  # discord.py checks this to know if it's a method vs function
-		getter.__self__ = cog  # discord.py uses this as the self argument
-
 		bot_log(None, cog.__class__, f"Creating /get {setting_name}")
 		command = Command(
 			name=setting_name,
 		return command
 
 	def __make_setter_command(self, cog: 'BaseCog') -> Command:
-		from rocketbot.cogs.basecog import BaseCog
 		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_general(cog0: BaseCog, interaction: Interaction, new_value) -> None:
-			print(f"invoking setter for {setting_name} with value {new_value}")
+		async def setter_general(interaction: Interaction, new_value) -> None:
 			try:
 				setting.validate_value(new_value)
 			except ValueError as ve:
 					ephemeral=True
 				)
 				return
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+			key = f'{cog.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(interaction.guild, key, setting.to_stored_value(new_value))
 			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} `{setting_name}` is now set to `{setting.to_native_value(new_value)}`',
 				ephemeral=True
 			)
-			await cog0.on_setting_updated(interaction.guild, setting)
-			cog0.log(interaction.guild, f'{interaction.user.name} set {key} to {new_value}')
+			await cog.on_setting_updated(interaction.guild, setting)
+			cog.log(interaction.guild, f'{interaction.user.name} set {key} to {new_value}')
 
 		setter: CommandCallback = setter_general
 		if self.datatype == int:
 				r_max = self.max_value
 				@rename(new_value=self.name)
 				@describe(new_value=self.brief)
-				async def setter_range(cog0, interaction: Interaction, new_value: Range[int, r_min, r_max]) -> None:
-					await setter_general(cog0, interaction, new_value)
+				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(cog0, interaction: Interaction, new_value: int) -> None:
-					await setter_general(cog0, interaction, new_value)
+				async def setter_int(interaction: Interaction, new_value: int) -> None:
+					await setter_general(interaction, new_value)
 				setter = setter_int
 		elif self.datatype == float:
 			@rename(new_value=self.name)
 			@describe(new_value=self.brief)
-			async def setter_float(cog0, interaction: Interaction, new_value: float) -> None:
-				await setter_general(cog0, interaction, new_value)
+			async def setter_float(interaction: Interaction, new_value: float) -> None:
+				await setter_general(interaction, new_value)
 			setter = setter_float
 		elif self.datatype == timedelta:
 			@rename(new_value=self.name)
 			@describe(new_value=f'{self.brief} (e.g. 30s, 5m, 1h30s, or 7d)')
-			async def setter_timedelta(cog0, interaction: Interaction, new_value: Transform[timedelta, TimeDeltaTransformer]) -> None:
-				await setter_general(cog0, interaction, new_value)
+			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(cog0, interaction: Interaction, new_value: dt) -> None:
-				await setter_general(cog0, interaction, new_value)
+			async def setter_enum(interaction: Interaction, new_value: dt) -> None:
+				await setter_general(interaction, new_value)
 			setter = setter_enum
 		elif self.datatype == str:
 			if self.enum_values is not None:
 			else:
 				@rename(new_value=self.name)
 				@describe(new_value=self.brief)
-				async def setter_str(cog0, interaction: Interaction, new_value: str) -> None:
-					await setter_general(cog0, interaction, new_value)
+				async def setter_str(interaction: Interaction, new_value: str) -> None:
+					await setter_general(interaction, new_value)
 				setter = setter_str
-		elif setting.datatype == bool:
+		elif self.datatype == bool:
 			@rename(new_value=self.name)
 			@describe(new_value=self.brief)
-			async def setter_bool(cog0, interaction: Interaction, new_value: bool) -> None:
-				await setter_general(cog0, interaction, new_value)
+			async def setter_bool(interaction: Interaction, new_value: bool) -> None:
+				await setter_general(interaction, new_value)
 			setter = setter_bool
-		elif setting.datatype is not None:
+		elif self.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}'
-		setter.__self__ = cog
+
 		bot_log(None, cog.__class__, f"Creating /set {setting_name} {self.datatype}")
 		command = Command(
 			name=setting_name,
 		return command
 
 	def __make_enable_command(self, cog: 'BaseCog') -> Command:
-		from rocketbot.cogs.basecog import BaseCog
 		setting: CogSetting = self
-		async def enabler(cog0: BaseCog, interaction: Interaction) -> None:
-			print(f"invoking enable for {cog0.config_prefix}")
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+		async def enabler(interaction: Interaction) -> None:
+			key = f'{cog.__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.user.name} enabled {cog0.__class__.__name__}')
-		setattr(cog.__class__, f'_cmd_enable', enabler)
-		enabler.__qualname__ = f'{cog.__class__.__name__}._cmd_enable'
-		enabler.__self__ = cog
-		bot_log(None, cog.__class__, f"Creating /enable {cog.config_prefix}")
+			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}")
 		command = Command(
 			name=cog.config_prefix,
 			description=f'Enables {cog.qualified_name} functionality.',
 		return command
 
 	def __make_disable_command(self, cog: 'BaseCog') -> Command:
-		from rocketbot.cogs.basecog import BaseCog
 		setting: CogSetting = self
-		async def disabler(cog0: BaseCog, interaction: Interaction) -> None:
-			print(f"invoking disable for {cog0.config_prefix}")
-			key = f'{cog0.__class__.__name__}.{setting.name}'
+		async def disabler(interaction: Interaction) -> None:
+			key = f'{cog.__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.user.name} disabled {cog0.__class__.__name__}')
-		setattr(cog.__class__, f'_cmd_disable', disabler)
-		disabler.__qualname__ = f'{cog.__class__.__name__}._cmd_disable'
-		disabler.__self__ = cog
-		bot_log(None, cog.__class__, f"Creating /disable {cog.config_prefix}")
+			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}")
 		command = Command(
 			name=cog.config_prefix,
 			description=f'Disables {cog.config_prefix} functionality',
 		)
 		return command
 
-	__has_set_up_base_commands: bool = False
 	__set_group: Group
 	__get_group: Group
 	__enable_group: Group
 			return
 		bot_log(None, cog.__class__, f"Setting up slash commands for {cog.__class__.__name__}")
 		for setting in settings:
-			setting.set_up(cog, bot)
+			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:
-		if cls.__has_set_up_base_commands:
+		if getattr(cls, f'_CogSetting__set_group', None) is not None:
 			return
-		cls.__has_set_up_base_commands = True
 		cls.__set_group = Group(
 			name='set',
 			description='Sets a configuration value for this guild.',
 								text += ('enabled' if deflt else 'disabled') + ' _(default)_'
 						else:
 							if value is not None:
-								text += f'\n- `{bcog.config_prefix}_{setting.name}` = **{setting.native_value_to_str(value)}**'
+								text += f'\n- `{bcog.config_prefix}_{setting.name}` = **{CogSetting.native_value_to_str(value)}**'
 							else:
-								text += f'\n- `{bcog.config_prefix}_{setting.name}` = {setting.native_value_to_str(deflt)} _(using default)_'
+								text += f'\n- `{bcog.config_prefix}_{setting.name}` = {CogSetting.native_value_to_str(deflt)} _(using default)_'
 				await interaction.response.send_message(
 					text,
 					ephemeral=True,