django.core.cache.cache.delete

Here are the examples of the python api django.core.cache.cache.delete taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

158 Examples 7

Example 1

Project: satchmo Source File: tests.py
    def setUp(self):
        # Every test needs a client
        cache_delete()
        self.client = Client()
        self.US = Country.objects.get(iso2_code__iexact = "US")
        rebuild_pricing()
        current_site = Site.objects.get_current()
        cache_key = "cat-%s-%s" % (current_site.id, get_language())
        cache.delete(cache_key)

Example 2

Project: django-pagebits Source File: models.py
@receiver(post_save, sender=PageBit)
def create_page_data(sender, instance, created, **kwargs):
    """ Handle automatically creating PageData items on creation """
    # Do nothing if we're loading a fixture
    if kwargs.get('raw', False):
        return

    if created:
        PageData.objects.create(bit=instance)

    # Bust the BitGroup cache
    key = bitgroup_cache_key(instance.context_name)
    cache.delete(key)

Example 3

Project: wger Source File: models.py
Function: save
    def save(self, *args, **kwargs):
        '''
        Reset all cached infos
        '''

        super(LanguageConfig, self).save(*args, **kwargs)

        # Cached objects
        cache.delete(cache_mapper.get_language_config_key(self.language, self.item))

        # Cached template fragments
        delete_template_fragment_cache('muscle-overview', self.language_id)
        delete_template_fragment_cache('exercise-overview', self.language_id)

Example 4

Project: dissemin Source File: models.py
Function: invalidate_cache
    def invalidate_cache(self):
        """
        Invalidate the HTML cache for all the publications of this researcher.
        """
        for a in self.authors+[None]:
            rpk = None
            if a:
                if a.researcher_id is None:
                    continue
                else:
                    rpk = a.researcher_id
            for lang in POSSIBLE_LANGUAGE_CODES:
                key = make_template_fragment_key(
                    'publiListItem', [self.pk, lang, rpk])
                cache.delete(key)

Example 5

Project: django-lockout Source File: utils.py
def reset_attempts(request):
    """Clears the cache key for the specified ``request``.
    """
    params = []
    ip = request.META.get('HTTP_X_FORWARDED_FOR', None)
    if ip:
        # X_FORWARDED_FOR returns client1, proxy1, proxy2,...
        ip = ip.split(', ')[0]
    else:
        ip = request.META.get('REMOTE_ADDR', '')
    params.append(ip)
    if settings.USE_USER_AGENT:
        useragent = request.META.get('HTTP_USER_AGENT', '')
        params.append(useragent)
        
    key = generate_base_key(*params)
    cache.delete(key)
    
########################################################################

Example 6

Project: pootle Source File: fields.py
Function: pre_save
    def pre_save(self, model_instance, add):
        value = super(MarkupField, self).pre_save(model_instance, add)

        if not add:
            # Invalidate cache to force rendering upon next retrieval
            cache_key = _rendered_cache_key(model_instance.__class__.__name__,
                                            model_instance.pk,
                                            self.name)
            logger.debug('Invalidating cache for %r', cache_key)
            cache.delete(cache_key)

        return value.raw

Example 7

Project: edx-platform Source File: models.py
Function: invalidate_cache_for_course
    @classmethod
    def invalidate_cache_for_course(cls, course_key):
        """Invalidate the cache. """
        cache_key = cls.CACHE_KEY.format(course_key=course_key)
        cache.delete(cache_key)
        log.info("Invalidated country access list for course %s", course_key)

Example 8

Project: splunk-webframework Source File: cached_db.py
Function: delete
    def delete(self, session_key=None):
        super(SessionStore, self).delete(session_key)
        if session_key is None:
            if self.session_key is None:
                return
            session_key = self.session_key
        cache.delete(KEY_PREFIX + session_key)

Example 9

Project: ganetimgr Source File: models.py
Function: migrate_instance
    def migrate_instance(self, instance):
        cache_key = self._instance_cache_key(instance)
        cache.delete(cache_key)
        job_id = self._client.MigrateInstance(instance)
        self._lock_instance(instance, reason="migrating", job_id=job_id)
        return job_id

Example 10

Project: Bundestagger Source File: utils.py
def invalidate_cache_all_pages(path, highest, max_per_page):
    last = get_page(highest,max_per_page)
    request = FakeRequest(path)
    cache.delete(get_cache_key(request))
    for i in range(last-1)+2:
        request = FakeRequest(path, {"page": last})
        cache.delete(get_cache_key(request))

Example 11

Project: storybase Source File: models.py
def invalidate_related_cache(sender, instance, field_name, language_key=True,
                             **kwargs):
    """
    Helper function for invalidating cached version of a Story's ManyToMany
    field.

    """
    action = kwargs.get('action')
    reverse = kwargs.get('reverse')
    if action in ("post_add", "post_remove", "post_clear") and not reverse:
        if not language_key:
            cache.delete(instance.related_key(field_name))
        else:
            languages = getattr(settings, 'LANGUAGES', None)
            if languages: 
                keys = []
                for (code, name) in settings.LANGUAGES:
                    keys.append(instance.related_key(field_name, code))
                cache.delete_many(keys)

Example 12

Project: django-scribbler Source File: models.py
@receiver(pre_save, sender=Scribble)
def clear_scribble_cache(sender, instance, **kwargs):
    "Clear cache pre-save in case slug/url has changed."
    if CACHE_TIMEOUT:
        raw = kwargs.get('raw', False)
        if instance.pk and not raw:
            # Need original slug/url from the DB
            original = Scribble.objects.get(pk=instance.pk)
            key = CACHE_KEY_FUNCTION(slug=original.slug, url=original.url)
            cache.delete(key)

Example 13

Project: transifex Source File: cache.py
def invalidate_template_cache(fragment_name, *variables):
    """This function invalidates a template cache.

    The template cache is named `fragment_name` and the variables are
    included in *variables. For example:

    {% cache 500 project_details project.slug LANGUAGE_CODE%}
        ...
    {% endcache %}

    We invalidate this by calling:
     -  invalidate_template_cache("project_details", project.slug)
    """
    for lang,code in settings.LANGUAGES:
        cur_vars = list(variables)
        cur_vars.append(unicode(lang))
        args = md5_constructor(u':'.join([urlquote(var) for var in cur_vars]))
        cache_key = 'template.cache.%s.%s' % (fragment_name, args.hexdigest())
        cache.delete(cache_key)

Example 14

Project: django-parler Source File: cache.py
def _delete_cached_translation(translation):
    if not appsettings.PARLER_ENABLE_CACHING:
        return

    # Delete a cached translation
    # For internal usage, object parameters are not suited for outside usage.
    key = get_translation_cache_key(translation.__class__, translation.master_id, translation.language_code)
    cache.delete(key)

Example 15

Project: coursys Source File: throttle.py
Function: process_response
    def process_response(self, request, response):
        # don't throttle after redirect, since immediate re-request is expected
        if response.status_code in REDIRS:
            key = self.request_key(request)
            cache.delete(key)

        return response

Example 16

Project: drawquest-web Source File: api.py
def invalidate_user_comments(comment):
    #TODO make django-cachecow namespaces dynamic, and then we can key it off the user ID and wipe it all in 
    # one go instead of deleting individual keys.
    author = comment.author
    pages = int(math.ceil(QuestComment.all_objects.filter(author=author).count() / float(knobs.COMMENTS_PER_PAGE)))

    for page in range(1, pages + 1) + ['top', None]:
        for viewer_is_author in [True, False]:
            for endpoint_key in ['user_comments']:
                key_args = [
                    endpoint_key,
                    _USER_COMMENTS_CACHE_VERSION,
                    author.username,
                    viewer_is_author,
                ]
                if page is not None:
                    key_args.append(page)
                key = make_key(key_args)
                cache.delete(key)

Example 17

Project: django-cached_authentication_middleware Source File: __init__.py
def invalidate_cache(sender, instance, **kwargs):
    if isinstance(instance, get_user_model()):
        key = CACHE_KEY % instance.id
    else:
        key = CACHE_KEY % instance.user_id
    cache.delete(key)

Example 18

Project: djep Source File: admin.py
def decline_reviewer_request(modeladmin, request, queryset):
    with commit_on_success():
        perm = utils.get_review_permission()
        for reviewer in queryset.select_related('user').all():
            reviewer.user.user_permissions.remove(perm)
        queryset.update(state=models.Reviewer.STATE_DECLINED)
        cache.delete('reviewer_pks')

Example 19

Project: djangopackages Source File: models.py
Function: save
    def save(self, *args, **kwargs):
        self.license = normalize_license(self.license)

        # reset the latest_version cache on the package
        cache_name = self.package.cache_namer(self.package.last_released)
        cache.delete(cache_name)
        get_version(self.package)

        # reset the pypi_version cache on the package
        cache_name = self.package.cache_namer(self.package.pypi_version)
        cache.delete(cache_name)
        get_pypi_version(self.package)

        super(Version, self).save(*args, **kwargs)

Example 20

Project: django-avatar Source File: utils.py
def invalidate_cache(user, size=None):
    """
    Function to be called when saving or changing an user's avatars.
    """
    sizes = set(settings.AVATAR_AUTO_GENERATE_SIZES)
    if size is not None:
        sizes.add(size)
    for prefix in cached_funcs:
        for size in sizes:
            cache.delete(get_cache_key(user, size, prefix))

Example 21

Project: wger Source File: models.py
Function: save
    def save(self, *args, **kwargs):
        '''
        Reset the cache
        '''

        super(Ingredient, self).save(*args, **kwargs)
        cache.delete(cache_mapper.get_ingredient_key(self.id))

Example 22

Project: zorna Source File: models.py
    def remove_perm(self, check, obj, user_or_group, acltype):

        kwargs = {}

        if isinstance(user_or_group, User):
            kwargs['user'] = user_or_group
        elif isinstance(user_or_group, UserGroup):
            kwargs['group'] = user_or_group
        else:
            return False
        content_type = ContentType.objects.get_for_model(obj)
        ACLPermission.objects.filter(
            object_id=obj.pk, content_type=content_type, user=user_or_group, permission=self.perms[check]).delete()
        cache.delete(ACL_USERS_PERMISSIONS_CACHE)
        cache.delete(ACL_GROUPS_PERMISSIONS_CACHE)
        return True

Example 23

Project: django-dbsettings Source File: loading.py
def set_setting_value(module_name, class_name, attribute_name, value):
    setting = get_setting(module_name, class_name, attribute_name)
    storage = get_setting_storage(module_name, class_name, attribute_name)
    storage.value = setting.get_db_prep_save(value)
    storage.save()
    key = _get_cache_key(module_name, class_name, attribute_name)
    cache.delete(key)

Example 24

Project: django-tracking2 Source File: handlers.py
def track_ended_session(sender, request, user, **kwargs):
    try:
        visitor = Visitor.objects.get(pk=request.session.session_key)
    # This should rarely ever occur.. e.g. direct request to logout
    except Visitor.DoesNotExist:
        return

    # Explicitly end this session. This improves the accuracy of the stats.
    visitor.end_time = timezone.now()
    visitor.time_on_site = (visitor.end_time - visitor.start_time).seconds
    visitor.save()

    # Unset the cache since the user logged out, this particular visitor will
    # unlikely be accessed individually.
    cache.delete(instance_cache_key(visitor))

Example 25

Project: tendenci Source File: cache.py
def delete_reg_apps_cache():
    """Delete cache for all apps
    """
    keys = [settings.CACHE_PRE_KEY, REGISTRY_PRE_KEY, 'reg_apps']
    key = '.'.join(keys)
    cache.delete(key)

Example 26

Project: storybase Source File: models.py
def invalidate_featured_asset_url_cache(sender, instance, **kwargs): 
    """Signal handler to invalidate a model's cached featured asset URL"""
    action = kwargs.get('action')
    reverse = kwargs.get('reverse')
    if action in ("post_add", "post_remove", "post_clear") and not reverse:
        key = instance.featured_asset_thumbnail_url_key()
        key_with_host = instance.featured_asset_thumbnail_url_key(include_host=True)
        cache.delete(key)
        cache.delete(key_with_host)

Example 27

Project: django-supertagging Source File: markup.py
def invalidate_markup_cache(obj, field):
    if not obj:
        return
        
    ctype = ContentType.objects.get_for_model(obj)
    key = "ST_HANDLER.%s.%s.%s" % (ctype.pk, obj.pk, field)
    cache.delete(key)

Example 28

Project: transifex Source File: utils.py
def invalidate_template_cache(fragment_name, *variables):
    """
    This function invalidates a template cache named `fragment_name` and with
    variables which are included in *variables. For example:

    {% cache 500 project_details project.slug %}
        ...
    {% endcache %}

    We invalidate this by calling:
     -  invalidate_template_cache("project_details", project.slug)
    """
    for lang,code in settings.LANGUAGES:
        cur_vars = list(variables)
        cur_vars.append(unicode(lang))
        args = md5_constructor(u':'.join([urlquote(var) for var in cur_vars]))
        cache_key = 'template.cache.%s.%s' % (fragment_name, args.hexdigest())
        cache.delete(cache_key)

Example 29

Project: django-lfc Source File: __init__.py
Function: delete_cache
def delete_cache(keys):
    """Deletes cache based on keys
    """
    if len(keys) == 1:
        cache.delete(keys[0])
    else:
        start = cache.get(keys[0])
        d = start
        for key in keys[1:-1]:
            d = d[key]

        del d[keys[-1]]
        cache.set(keys[0], start)

Example 30

Project: coursys Source File: models.py
def clear_offering_cache(instance, **kwargs):
    """
    Saving an activity might change HTML contents of any PageVersion, since they might
    contain <<duedate>> macros: invalidate all cached copies to be safe.
    """
    if not isinstance(instance, Activity):
        return
    if not hasattr(instance, 'offering'):
        # doesn't have an offering set yet: can't be a problem. Right?
        return

    for pv in PageVersion.objects.filter(page__offering=instance.offering):
        key = pv.html_cache_key()
        cache.delete(key)

Example 31

Project: django-cms Source File: permissions.py
def clear_user_permission_cache(user):
    """
    Cleans permission cache for given user.
    """
    from django.core.cache import cache
    for key in PERMISSION_KEYS:
        cache.delete(get_cache_key(user, key), version=get_cache_permission_version())

Example 32

Project: pootle Source File: models.py
@receiver([post_delete, post_save])
def invalidate_resources_cache(**kwargs):
    instance = kwargs["instance"]
    if instance.__class__.__name__ not in ['Directory', 'Store']:
        return

    # Don't invalidate if the save didn't create new objects
    no_new_objects = (
        ('created' in kwargs
         and 'raw' in kwargs)
        and (not kwargs['created']
             or kwargs['raw']))

    if no_new_objects and instance.parent.get_children():
        return

    proj_code = split_pootle_path(instance.pootle_path)[1]
    if proj_code is not None:
        cache.delete(make_method_key(Project, 'resources', proj_code))

Example 33

Project: site Source File: organization.py
    def handle(self, request, org, profile):
        if profile.organizations.filter(id=org.id).exists():
            return generic_message(request, _('Joining organization'), _('You are already in the organization.'))
        if not org.is_open:
            return generic_message(request, _('Joining organization'), _('This organization is not open.'))
        profile.organizations.add(org)
        profile.save()
        cache.delete(make_template_fragment_key('org_member_count', (org.id,)))

Example 34

Project: djangopackages Source File: models.py
Function: save
    def save(self, *args, **kwargs):
        # reset the last_updated and commits_over_52 caches on the package
        package = self.package
        cache.delete(package.cache_namer(self.package.last_updated))
        cache.delete(package.cache_namer(package.commits_over_52))
        self.package.last_updated()
        super(Commit, self).save(*args, **kwargs)

Example 35

Project: 2buntu-blog Source File: models.py
@receiver(models.signals.post_save, sender=Article)
def clear_cache_and_remove_scheduled(instance, created, **kwargs):
    """
    Clear the cache and remove any scheduled articles instance.
    """
    if not created:
        cache.delete(instance.markdown_key)
    if instance.status == Article.PUBLISHED:
        ScheduledArticle.objects.filter(article=instance).delete()

Example 36

Project: python-useful Source File: cached_auth.py
Function: invalidate_cache
def invalidate_cache(sender, instance, **kwargs):  # @UnusedVariable
    if isinstance(instance, UserModel):
        key = CACHE_KEY % instance.id
    else:
        key = CACHE_KEY % instance.user_id

    cache.cache.delete(key)

Example 37

Project: edx-platform Source File: models.py
Function: invalidate_cache_for_course
    @classmethod
    def invalidate_cache_for_course(cls, course_key):
        """Invalidate the caches for the restricted course. """
        cache.delete(cls.COURSE_LIST_CACHE_KEY)
        log.info("Invalidated cached list of restricted courses.")

        for access_point in ['enrollment', 'courseware']:
            msg_cache_key = cls.MESSAGE_URL_CACHE_KEY.format(
                access_point=access_point,
                course_key=course_key
            )
            cache.delete(msg_cache_key)
        log.info("Invalidated cached messaging URLs ")

Example 38

Project: django-cache-sweeper Source File: tests.py
    def test_default_version_zero(self):
        tmm = TestMixinModel(text='testing text')
        tmm.save()
        cache.delete(tmm.cachesweeper_version_key)
        self.assertEquals(tmm.cachesweeper_version, 0)
        tmm.save()
        self.assertEquals(tmm.cachesweeper_version, 1)
    
    # def test_modelsweeper_manager(self):
    #     tmm = TestManagerModel(text='testing text')
    #     self.assertTrue(hasattr(tmm.cachesweeper,'cachesweeper'))

Example 39

Project: djep Source File: admin.py
def accept_reviewer_request(modeladmin, request, queryset):
    with commit_on_success():
        perm = utils.get_review_permission()
        for reviewer in queryset.select_related('user').all():
            reviewer.user.user_permissions.add(perm)
        queryset.update(state=models.Reviewer.STATE_ACCEPTED)
        cache.delete('reviewer_pks')

Example 40

Project: django-cachalot Source File: read.py
    def test_missing_table_cache_key(self):
        with self.assertNumQueries(1):
            list(Test.objects.all())
        with self.assertNumQueries(0):
            list(Test.objects.all())

        table_cache_key = _get_table_cache_key(connection.alias,
                                               Test._meta.db_table)
        cache.delete(table_cache_key)

        with self.assertNumQueries(1):
            list(Test.objects.all())

Example 41

Project: feincms Source File: translations.py
    def purge_translation_cache(self):
        cache.delete(self.get_translation_cache_key())
        for lang in self.available_translations:
            cache.delete(self.get_translation_cache_key(lang))

        try:
            del self._cached_translation
        except AttributeError:
            pass

Example 42

Project: contentious Source File: api.py
Function: clear_caches
    def _clear_caches(self, template_context):
        """ Clear our caches from both the request object and memcache. """
        request = template_context['request']
        try:
            del request._content_cache_dict
        except AttributeError:
            pass
        cache.delete(content_dict_cache_key())

Example 43

Project: frigg-hq Source File: models.py
Function: save
    def save(self, *args, **kwargs):
        create = self.pk is None
        super(User, self).save(*args, **kwargs)
        cache.delete('projects:permitted:{}'.format(self.username))
        if create:
            self.update_repo_permissions()

Example 44

Project: wger Source File: models.py
Function: delete
    def delete(self, *args, **kwargs):
        '''
        Reset all cached infos
        '''

        # Cached objects
        cache.delete(cache_mapper.get_language_config_key(self.language, self.item))

        # Cached template fragments
        delete_template_fragment_cache('muscle-overview', self.language_id)
        delete_template_fragment_cache('exercise-overview', self.language_id)

        super(LanguageConfig, self).delete(*args, **kwargs)

Example 45

Project: Bundestagger Source File: utils.py
Function: invalidate_cache
def invalidate_cache(path, *args):
    page = None
    if len(args)==2:
        index, max_per_page = args
        page = get_page(index, max_per_page)
    if page is not None and page != 1:
        request = FakeRequest(path, {"page": page})
    else:
        request = FakeRequest(path)
    cache.delete(get_cache_key(request))

Example 46

Project: django-allauth Source File: adapter.py
    def authenticate(self, request, **credentials):
        """Only authenticates, does not actually login. See `login`"""
        self.pre_authenticate(request, **credentials)
        user = authenticate(**credentials)
        if user:
            cache_key = self._get_login_attempts_cache_key(
                request, **credentials)
            cache.delete(cache_key)
        else:
            self.authentication_failed(request, **credentials)
        return user

Example 47

Project: contentious Source File: api.py
Function: clear_caches
    def _clear_caches(self, template_context):
        """ Clear our caches from both the request object and memcache. """
        language = self._get_lang(template_context)
        request = template_context['request']
        try:
            del request._content_cache_dict
        except AttributeError:
            pass
        cache.delete(content_dict_cache_key(language))

Example 48

Project: coursys Source File: models.py
    def expire_offering_cache(self):
        # invalidate cache for all pages in this offering: makes sure current page, and all <<filelist>> are up to date
        for pv in PageVersion.objects.filter(page__offering=self.offering):
            cache.delete(pv.html_cache_key())
            cache.delete(pv.wikitext_cache_key())
        # other cache cleanup
        cache.delete(self.version_cache_key())
        cache.delete(self.macro_cache_key())

Example 49

Project: tendenci Source File: utils.py
def delete_setting_cache(scope, scope_category, name):
    """
        Deletes a single setting within a
        scope and scope category
    """
    keys = [d_settings.CACHE_PRE_KEY, SETTING_PRE_KEY, scope,
            scope_category, name]
    key = '.'.join(keys)
    cache.delete(key)

Example 50

Project: crate-site Source File: views.py
    def post(self, request, *args, **kwargs):
        try:
            package = Package.objects.get(name=kwargs.get("package"))
        except Package.DoesNotExist:
            return self.render_json(package=kwargs.get("package"), success=False, message="Package does not exist")

        fav = Favorite.objects.filter(package=package, user=request.user)

        cache.delete(FAVORITES_QUERYSET_KEY % self.request.user.pk, version=FAVORITES_CACHE_VERSION)

        if fav:
            fav.delete()
            return self.render_json(package=package.name, success=True, action="unfavorite")
        else:
            Favorite.objects.create(package=package, user=request.user)
            return self.render_json(package=package.name, success=True, action="favorite")
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4