Python django.core.cache.cache.delete_many() Examples

def problem_update(sender, instance, **kwargs):
    if hasattr(instance, '_updating_stats_only'):
        return

    cache.delete_many([
        make_template_fragment_key('submission_problem', (instance.id,)),
        make_template_fragment_key('problem_feed', (instance.id,)),
        'problem_tls:%s' % instance.id, 'problem_mls:%s' % instance.id,
    ])
    cache.delete_many([make_template_fragment_key('problem_html', (instance.id, engine, lang))
                       for lang, _ in settings.LANGUAGES for engine in EFFECTIVE_MATH_ENGINES])
    cache.delete_many([make_template_fragment_key('problem_authors', (instance.id, lang))
                       for lang, _ in settings.LANGUAGES])
    cache.delete_many(['generated-meta-problem:%s:%d' % (lang, instance.id) for lang, _ in settings.LANGUAGES])

    for lang, _ in settings.LANGUAGES:
        unlink_if_exists(get_pdf_path('%s.%s.pdf' % (instance.code, lang))) 

def profile_update(sender, instance, **kwargs):
    if hasattr(instance, '_updating_stats_only'):
        return

    cache.delete_many([make_template_fragment_key('user_about', (instance.id, engine))
                       for engine in EFFECTIVE_MATH_ENGINES] +
                      [make_template_fragment_key('org_member_count', (org_id,))
                       for org_id in instance.organizations.values_list('id', flat=True)]) 

def contest_update(sender, instance, **kwargs):
    if hasattr(instance, '_updating_stats_only'):
        return

    cache.delete_many(['generated-meta-contest:%d' % instance.id] +
                      [make_template_fragment_key('contest_html', (instance.id, engine))
                       for engine in EFFECTIVE_MATH_ENGINES]) 

def language_update(sender, instance, **kwargs):
    cache.delete_many([make_template_fragment_key('language_html', (instance.id,)),
                       'lang:cn_map']) 

def post_update(sender, instance, **kwargs):
    cache.delete_many([
        make_template_fragment_key('post_summary', (instance.id,)),
        'blog_slug:%d' % instance.id,
        'blog_feed:%d' % instance.id,
    ])
    cache.delete_many([make_template_fragment_key('post_content', (instance.id, engine))
                       for engine in EFFECTIVE_MATH_ENGINES]) 

def misc_config_cache_delete(key):
    cache.delete_many(['misc_config:%s:%s:%s' % (domain, lang, key.split('.')[0])
                       for lang in _misc_config_i18n
                       for domain in Site.objects.values_list('domain', flat=True)]) 

def finished_submission(sub):
    keys = ['user_complete:%d' % sub.user_id, 'user_attempted:%s' % sub.user_id]
    if hasattr(sub, 'contest'):
        participation = sub.contest.participation
        keys += ['contest_complete:%d' % participation.id]
        keys += ['contest_attempted:%d' % participation.id]
    cache.delete_many(keys) 

def save(self, *args, **kwargs):
        super().save(*args, **kwargs)
        cache.delete_many(self._bulk_invalidation_cache_keys) 

def test_delete_many(self):
        # Multiple keys can be deleted using delete_many
        cache.set("key1", "spam")
        cache.set("key2", "eggs")
        cache.set("key3", "ham")
        with self.assertNumQueries(1):
            cache.delete_many(["key1", "key2"])
        assert cache.get("key1") is None
        assert cache.get("key2") is None
        assert cache.get("key3") == "ham" 

def revoke_user_course_permissions(user):
    """
    Revokes all course permissions for the given user.

    Arguments
        user (User) --  User for which permissions should be revoked
    """
    cache.delete_many(_get_course_permission_cache_keys(user)) 

def invalidate_schematics(self):
        cache.delete_many([self.name + "_cons_schematic",self.name + "_wt_schematic",self.name + "_chem_summary"])
        self.schematics = None
        self.save() 

def save(self, *args, **kwargs):
        super(Instagram, self).save(*args, **kwargs)
        cache_keys = (
            self.get_cache_key(prefix='profile_%s' % self.user_id.strip()),
            self.get_cache_key(prefix='profile_%s' % self.account.uid),
            self.get_cache_key(prefix='location_%s' % self.location_id.strip()),
            self.get_cache_key(prefix='media'),
        )
        cache.delete_many(cache_keys) 

def clear_cache(model):
    cache_object_key = helper.cache_object_key(model)
    obj_methods_caches = django_cache.get(cache_object_key)
    methods_key = obj_methods_caches.split('|')
    django_cache.delete_many(methods_key) 

def remove_cleaned_articles(articles):
    cache.delete_many([cache_id_to_key(a.id) for a in articles])