Python django.db.models.signals.post_migrate.connect() Examples

def retry_handler_registration(sender, **kwargs):
    """
    Goes through each of the handlers to retry
    and retries them w/ retry=False
    """

    while len(query_handlers_to_retry):
        qh = query_handlers_to_retry.pop()
        register_query_handler(qh[0], qh[1], retry=False)

    while len(message_handlers_to_retry):
        mh = message_handlers_to_retry.pop()
        print("retrying", mh[0])
        register_message_handler(mh[0], mh[1], retry=False)

# Leaving the sender blank is probably not right, but
# after a few hours digging in django source code i couldn't
# figure out another way to connect this handler so
# it stays this way for now 

def ready(self):
        if django_version() == DjangoVersion.DJANGO_21:
            # Disable silently the package for Django => 2.1. We don't override
            # admin_site neither the default ModelAdmin.
            warnings.warn(
                'The package `admin_view_permission is deprecated in '
                'Django 2.1. Django added this functionality into the core.',
                DeprecationWarning
            )
            return

        if not isinstance(admin.site, AdminViewPermissionAdminSite):
            admin.site = AdminViewPermissionAdminSite('admin')
            admin.sites.site = admin.site

        post_migrate.connect(update_permissions) 

def prepare(self):
        """Connect testing ``pre_migrate`` and ``post_migrate`` receivers."""
        self.pre_migrate_receiver_mock = mock.MagicMock()
        self.post_migrate_receiver_mock = mock.MagicMock()
        # ``old_apps`` is not real ``ProjectState`` instance, so we cannot use
        # it to get "original" main_app ``AppConfig`` instance needed to
        # connect signal receiver, that's the reason we are using
        # ``apps`` imported directly from ``django.apps``
        self.main_app_config = apps.get_app_config('main_app')
        pre_migrate.connect(
            self.pre_migrate_receiver_mock,
            sender=self.main_app_config,
        )
        post_migrate.connect(
            self.post_migrate_receiver_mock,
            sender=self.main_app_config,
        ) 

def ready(self):
        post_migrate.connect(default_data_setup, sender=self)
        import_module("radio.receivers") 

def setUp(self):
        from django.db.models.signals import post_save, post_delete
        try:
            from django.db.models.signals import post_migrate
        except ImportError:  # django <= 1.6
            from django.db.models.signals import post_syncdb as post_migrate

        from django_elasticsearch.models import es_save_callback
        from django_elasticsearch.models import es_delete_callback
        from django_elasticsearch.models import es_syncdb_callback
        try:
            from django.apps import apps
            app = apps.get_app_config('django_elasticsearch')
        except ImportError: # django 1.4
            from django.db.models import get_app
            app = get_app('django_elasticsearch')

        post_save.connect(es_save_callback)
        post_delete.connect(es_delete_callback)
        post_migrate.connect(es_syncdb_callback)
        
        if int(get_version()[2]) >= 6:
            sender = app
        else:
            sender = None
        post_migrate.send(sender=sender,
                          app_config=app,
                          app=app,  # django 1.4
                          created_models=[TestModel,],
                          verbosity=2)

        self.instance = TestModel.objects.create(username=u"1",
                                                 first_name=u"woot",
                                                 last_name=u"foo")
        self.instance.es.do_index() 

def ready(self):

        from admin_interface import settings
        from admin_interface.models import Theme

        settings.check_installed_apps()
        post_migrate.connect(
            Theme.post_migrate_handler, sender=self) 

def ready(self):
        post_migrate.connect(create_permissions,
            dispatch_uid="django.contrib.auth.management.create_permissions")
        checks.register(check_user_model, checks.Tags.models) 

def ready(self):
        post_migrate.connect(update_contenttypes)
        checks.register(check_generic_foreign_keys, checks.Tags.models) 

def ready(self):
        post_migrate.connect(create_default_site, sender=self) 

def ready(self):
        post_migrate.connect(
            create_permissions,
            dispatch_uid="django.contrib.auth.management.create_permissions"
        )
        checks.register(check_user_model, checks.Tags.models)
        checks.register(check_models_permissions, checks.Tags.models) 

def ready(self):
        import cfp.signals  # noqa
        post_migrate.connect(cfp.signals.call_first_site_post_save, sender=self) 

def ready(self):
        from promgen import signals, checks  # NOQA

        post_migrate.connect(default_shard, sender=self)
        post_migrate.connect(default_admin, sender=self) 

def ready(self):
        """
        For postgresql only, remove like indexes for uuid columns and
        create version-unique indexes.

        This will only be run in django >= 1.7.

        :return: None
        """
        if connection.vendor == 'postgresql':
            post_migrate.connect(index_adjustments, sender=self) 

def ready(self, *args, **kwargs):
        from . import signals
        post_migrate.connect(signals.update_resources, sender=self) 

def ready(self):
        post_migrate.connect(create_default_template, sender=self) 

def ready(self):
        from .models import Bug
        from .management import create_permissions
        from tcms import signals

        post_save.connect(signals.handle_emails_post_bug_save, sender=Bug)
        post_migrate.connect(
            create_permissions,
            dispatch_uid="tcms.bugs.management.create_permissions"
        ) 

def ready(self):
        pre_migrate.connect(create_index, sender=self)
        post_migrate.connect(reindex, sender=self) 

def ready(self):
        post_migrate.connect(
            create_permissions,
            dispatch_uid="django.contrib.auth.management.create_permissions"
        )
        last_login_field = getattr(get_user_model(), 'last_login', None)
        # Register the handler only if UserModel.last_login is a field.
        if isinstance(last_login_field, DeferredAttribute):
            from .models import update_last_login
            user_logged_in.connect(update_last_login, dispatch_uid='update_last_login')
        checks.register(check_user_model, checks.Tags.models)
        checks.register(check_models_permissions, checks.Tags.models) 

def ready(self):
        """Django callback when application is loaded"""

        # register our interest in the post_migrate signal
        post_migrate.connect(post_migration_callback, sender=self)

        if RUNSERVER:
            try:
                check_external_services()
            except RuntimeError as error:
                print('Startup checks failed. Not starting.')
                print(error)
                exit(-1)  # Django doesn't seem to do this automatically. 

def ready(self):
        super(RaConfig, self).ready()
        from .utils.permissions import create_report_permissions
        from . import checks

        post_migrate.connect(
            create_report_permissions, sender=self,
            dispatch_uid="ra.utils.permissions.create_reports_permissions"
        ) 

def ready(self):
        from ra.utils.permissions import create_report_permissions
        super().ready()
        post_migrate.connect(
            create_report_permissions, sender=self) 

def ready(self) -> None:
        # We import zerver.signals here for the side effect of
        # registering the user_logged_in signal receiver.  This import
        # needs to be here (rather than e.g. at top-of-file) to avoid
        # running that code too early in Django's setup process, but
        # in any case, this is an intentionally unused import.
        import zerver.signals
        zerver.signals

        if settings.POST_MIGRATION_CACHE_FLUSHING:
            post_migrate.connect(flush_cache, sender=self) 

def ready(self):
        from django.contrib.sites.models import Site

        from job_board.signals import gen_site_config_post_migrate
        from job_board.signals import gen_site_config_post_save

        post_save.connect(gen_site_config_post_save, sender=Site)
        # NOTE: We list sites before job_board in INSTALLED_APPS, failing to
        #       do that will result in this post_migrate signal firing before
        #       the default site has been created.
        post_migrate.connect(gen_site_config_post_migrate, sender=self) 

def ready(self):
        post_migrate.connect(init_db, sender=self) 

def ready(self):
        post_migrate.connect(init_db, sender=self) 

def ready(self):
        post_migrate.connect(
            lambda sender, **kwargs: generate_view_permissions(),
            sender=self,
            weak=False,
        ) 

def ready(self):
        post_migrate.connect(
            create_permissions,
            dispatch_uid="django.contrib.auth.management.create_permissions"
        )
        if hasattr(get_user_model(), 'last_login'):
            from .models import update_last_login
            user_logged_in.connect(update_last_login, dispatch_uid='update_last_login')
        checks.register(check_user_model, checks.Tags.models)
        checks.register(check_models_permissions, checks.Tags.models) 

def patch():
    post_migrate.connect(_invalidate_on_migration)

    _patch_cursor()
    _patch_atomic()
    _patch_orm() 

def ready(self):
        post_migrate.connect(create_default_site, sender=self) 

def ready(self):
        post_migrate.connect(update_contenttypes)
        checks.register(check_generic_foreign_keys, checks.Tags.models)