Função Callback do Receiver (dispatch do Django) não Dispara

Programação Python
#1

Já realizei dezenas de testes. Usei o loop do método que cria o listener (código abaixo), para executar a chamada do save do Group (django.contrib.auth.models), mas a função do listener só é disparada quando ambas as chamadas estão no mesmo método. Mesmo se estiverem na mesma classe, mas em métodos diferentes, ou mesmo se estiverem no mesmo método, mas em chamadas a este método diferentes, não dispara.

from asgiref.sync import async_to_sync, sync_to_async
from django.dispatch import receiver
from django.contrib.auth.models import Group, Permission
import asyncio
import traceback
class ListenerDataBase():
    async def create_listener(self, methodRESTSignal, ModelDataBase, async_callback):
        '''
            O parâmetro async_callback precisa ser uma função assíncrona com 3 parâmetros
        '''
        @receiver(methodRESTSignal, sender=ModelDataBase)
        def trigger_async_callback(sender, instance, **kwargs):
            print(f'trigguer_async_call disparada')
            sync_callback = async_to_sync(async_callback)(sender, instance, **kwargs)
            sync_callback()
        #se a chamada a group.save() for feita, aqui, a função trigger_async_callback é executada

            
    async def create_group(self, group_name):
        def wrap_sync(self, group_name):
            try:
                group = Group(name=group_name)
                group.save()
            except Exception as e:
                logger.error(f'Error inside wrap_sync -> {traceback.format_exc()}')
        async_create_group = sync_to_async(wrap_sync) # (group_name)
        await async_create_group(self, group_name)
#2

O Problema Principal
Os sinais no Django, como o post_save ou qualquer sinal personalizado que você esteja utilizando com receiver, precisam ser registrados antes que a instância do modelo seja salva. O motivo pelo qual a callback só é disparada quando tudo está no mesmo método é porque, neste caso, o sinal está sendo registrado e o save() está sendo chamado quase que imediatamente após o registro.

Tente esta solução

from asgiref.sync import async_to_sync, sync_to_async
from django.dispatch import receiver, Signal
from django.contrib.auth.models import Group
import asyncio
import logging

# Defina o logger para capturar erros
logger = logging.getLogger(__name__)

class ListenerDataBase():
    def __init__(self):
        self.methodRESTSignal = Signal()  # Exemplo de sinal customizado para teste

    async def create_listener(self, ModelDataBase, async_callback):
        '''
            O parâmetro async_callback precisa ser uma função assíncrona com 3 parâmetros
        '''
        @receiver(self.methodRESTSignal, sender=ModelDataBase)
        def trigger_async_callback(sender, instance, **kwargs):
            print('trigger_async_callback disparada')
            try:
                async_to_sync(async_callback)(sender, instance, **kwargs)
            except Exception as e:
                logger.error(f'Error inside trigger_async_callback -> {traceback.format_exc()}')
        
        # Agora, o listener está registrado para o modelo especificado.

    async def create_group(self, group_name):
        def wrap_sync(group_name):
            try:
                group = Group(name=group_name)
                group.save()

                # Dispare o sinal manualmente após salvar o grupo
                self.methodRESTSignal.send(sender=Group, instance=group)
            except Exception as e:
                logger.error(f'Error inside wrap_sync -> {traceback.format_exc()}')
        
        async_create_group = sync_to_async(wrap_sync)
        await async_create_group(group_name)