python类delete()的实例源码

def get_context_data(self, **kwargs):
        logger.debug('GET: DeleteMissionView (Confirm delete {mission_id})'
                     .format(mission_id=self.object.id))
        return super(DeleteMissionView, self).get_context_data(**kwargs)

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)

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)

def invalidate_user_cache(sender, **kwargs):
    key = generate_cache_key(kwargs.get('instance'))
    cache.delete(key)

def invalidate_group_cache(sender, **kwargs):
    users = kwargs.get('instance').user_set.all()
    for user in users:
        key = generate_cache_key(user)
        cache.delete(key)

def invalidate_user_m2m_cache(sender, **kwargs):
    key = generate_cache_key(kwargs.get('instance'))
    cache.delete(key)

def ready(self):
        from django.shortcuts import resolve_url
        from django.core.cache import cache
        from libs.js_storage import JS_STORAGE
        cache.delete('attachable_block_types')

        JS_STORAGE.update({
            'ajax_attached_block': resolve_url('blocks:ajax'),
        })

def clear_newsletter_cache(*args, **kwargs):
    cache.delete(CACHE_KEY)

def clear_sms_cache(*args, **kwargs):
    cache.delete(SMS_CACHE_KEY)

def delete_user(modeladmin, request, queryset):
    for world in queryset:
        user = User.objects.get(id=world.worldid)
        user.is_active = False
        user.save()
        world.delete()

def ban_user(modeladmin, request, queryset):
    for world in queryset:
        banip = world.lastloggedinip
        user = User.objects.get(id=world.worldid)
        user.is_active = False
        user.save()
        world.delete()
    try: Ban.objects.create(address=banip, reason='Multying')
    except: pass

def clear_ban(modeladmin, request, queryset):
    for ban in queryset:
        cache.delete('BAN:'+ban.address)
        ban.delete()

def invalidate(public_video_id):
    cache.delete(_cache_key(public_video_id))

def release_lock(name):
    """
    Release a lock for all. Note that the lock will be released even if it was
    never acquired.
    """
    # Note that in unit tests, and in case the wrapped code raises an
    # IntegrityError, releasing the cache will result in a
    # TransactionManagementError. This is because unit tests run inside atomic
    # blocks. We cannot execute queries inside an atomic block if a transaction
    # needs to be rollbacked.
    try:
        cache.delete(name)
    except TransactionManagementError:
        logger.error("Could not release lock %s", name)

def transcode_video_restart():
    with Lock('TASK_LOCK_TRANSCODE_VIDEO_RESTART', 60) as lock:
        if lock.is_acquired:
            for processing_state in models.ProcessingState.objects.filter(status=models.ProcessingState.STATUS_RESTART):
                send_task('transcode_video', args=(processing_state.video.public_id,), kwargs={'delete': False})

def clean_upload_urls():
    """
    Remove video upload urls which cannot be used anymore.
    """
    models.VideoUploadUrl.objects.obsolete().delete()

def clean_old_cache_content():
    """Clean CACHE data from old versions of django-modern-rpc"""
    cache.delete('__rpc_registry__', version=1)

def expire_json_cache(system_name):
    cache.delete('json_cache:%s' % system_name)

def cache_evict(sender, **kwargs):
    """ signal for updating a model instance in the cache; any Model class using this signal must
    have a uniquely identifying 'cache_key' property. 

    """
    item = kwargs.get('instance')
    cache.delete(item.cache_key)

def cache_meeting_page(timeout=60*10, render_timeout=15):
    def _decorator(fn):
        @wraps(fn)
        def _inner(*args, **kwargs):
            meeting_pk = kwargs.pop('meeting_pk')
            # getting the meeting from the database is an implicit permission check
            meeting = get_object_or_404(Meeting, pk=meeting_pk)
            kwargs['meeting'] = meeting
            cache_key = cache_key_for_meeting_page(meeting, fn)
            lock_key = cache_key + ':render-lock'
            while True:
                html = cache.get(cache_key)
                if html is None:
                    if cache.add(lock_key, 'in-progress', render_timeout):
                        break
                    else:
                        time.sleep(1)
                else:
                    return HttpResponse(html)
            try:
                html = fn(*args, **kwargs)
                cache.set(cache_key, html, timeout)
                return HttpResponse(html)
            finally:
                cache.delete(lock_key)
        return _inner
    return _decorator