How do cogs pass self into command callbacks?

[showierdata9978]

Normally with function decorators that store the base method, and then the base method is called somewhere else without access to the class, you can't bind self to the method (so that it can access insistence vars)

[EmreTech]

Application commands are bound to a cog when an instance of a cog is created, so when the callback inside of an application command is called, the cog instance is the first argument passed in.

[showierdata9978]

so its a more complicated version of this? (just wrote it)

class Cog(metaclass=ABCMeta):
    instence = None
    _Cog_commands = None

    def __new__(cls):
        if cls.instence is None:
            cls.instence = super().__new__(cls)
        return cls.instence

    @classmethod
    def __subclasshook__(cls):
        cls._Cog_commands = {} # to make cogs not share cmds

    @classmethod
    def register_command(cls, command):
        cls._Cog_commands[command.name] = command
    
    
    def get_commands(self):
        for cmd in self._Cog_commands:
            cmd.func = getattr(self, cmd.func.__name__) # binding self 
        
        return self._Cog_commands

... another file


def command(name=None, arg_count=0, bot=None):
    def inner(func):
        @functools.wraps(func)
        def callfunc(*args, **kwargs):
            raise NotImplementedError("This Should Never be called\n it should disapear")
        
        cmd = _Command(func, name, arg_count)

        if hasattr(func, "__class__"):
            func.__class__.register_command(cmd)
        elif bot is not None:
            bot.commands[cmd.name] = cmd
        else:
            Bot.register_command(cmd)


        return callfunc

[EmreTech]

Not quite. The cog class looks for application commands defined within itself then modifies them to set themselves as the cog in the application command.

nextcord/nextcord/application_command.py

Lines 476 to 511 in 22eb5d1

	class ClientCog:
	# TODO: I get it's a terrible name, I just don't want it to duplicate current Cog right now.
	# __cog_application_commands__: List[ApplicationCommand]
	# __cog_to_register__: List[ApplicationCommand]
	__cog_application_commands__: List[BaseApplicationCommand]
	def __new__(cls, *args: Any, **kwargs: Any):
	new_cls = super(ClientCog, cls).__new__(cls)
	new_cls._read_application_commands()
	return new_cls
	def _read_application_commands(self) -> None:
	"""Iterates through the application (sub)commands contained within the ClientCog, runs their from_callback
	methods, then adds them to the internal list of application commands for this cog.
	"""
	self.__cog_application_commands__ = []
	for base in reversed(self.__class__.__mro__):
	for _, value in base.__dict__.items():
	is_static_method = isinstance(value, staticmethod)
	if is_static_method:
	value = value.__func__
	if isinstance(value, SlashApplicationCommand):
	value.parent_cog = self
	value.from_callback(value.callback, call_children=False)
	self.__cog_application_commands__.append(value)
	elif isinstance(value, SlashApplicationSubcommand):
	# As subcommands are part of a parent command and
	# not usable on their own, we don't add them to the command list, but do set the self_argument and
	# run them from the callback.
	value.parent_cog = self
	value.from_callback(value.callback, call_children=False)
	elif isinstance(value, BaseApplicationCommand):
	value.parent_cog = self
	value.from_callback(value.callback)
	self.__cog_application_commands__.append(value)

[EmreTech]

The slash_command, user_command, and message_command decorators defined in the nextcord module (so not the decorators defined in nextcord.Client) just convert the decorated function into an appropriate BaseApplicationCommand subclass.