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
3
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)
3
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)
3
Example 3
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)
3
Example 4
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)
3
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)
########################################################################
3
Example 6
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
3
Example 7
@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)
3
Example 8
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)
3
Example 9
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
3
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))
3
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)
3
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)
3
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)
3
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)
3
Example 15
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
3
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)
3
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)
3
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')
3
Example 19
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)
3
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))
3
Example 21
def save(self, *args, **kwargs):
'''
Reset the cache
'''
super(Ingredient, self).save(*args, **kwargs)
cache.delete(cache_mapper.get_ingredient_key(self.id))
3
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
3
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)
3
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))
3
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)
3
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)
3
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)
3
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)
3
Example 29
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)
3
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)
3
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())
3
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))
3
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,)))
3
Example 34
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)
3
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()
3
Example 36
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)
3
Example 37
@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 ")
3
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'))
3
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')
3
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())
3
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
3
Example 42
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())
3
Example 43
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()
3
Example 44
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)
3
Example 45
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))
3
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
3
Example 47
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))
3
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())
3
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)
3
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")