Remove key from memory, leaving file in place.

        This forces :py:meth:`~bucketcache.buckets.DeferredWriteBucket.sync`.
435771
def unload_key(self, key):
        
        self.sync()
        return super(DeferredWriteBucket, self).unload_key(key)
809959
def delete_value(self, key):
        
        response = {}
        response['status'] = False
        response['msg'] = "key does not exist"

        file_cache = self.read_file()
        if key in file_cache:
            del file_cache[key]
            self.update_file(file_cache)
            response['status'] = True
            response['msg'] = "success"
        return response
1324322
def delete(key, service=None, profile=None):  # pylint: disable=W0613
    '''
    
    '''
    key, profile = _parse_key(key, profile)
    cache = salt.cache.Cache(__opts__)
    try:
        cache.flush(profile['bank'], key=key)
        return True
    except Exception:
        return False
1189951
def remove_unnecessary_cache_files!
      current_keys = cache_files.map do |file|
        get_cache_key_from_filename(file)
      end
      inmemory_keys = responses.keys

      unneeded_keys = current_keys - inmemory_keys
      unneeded_keys.each do |key|
        File.unlink(filepath_for(key))
      end
    end
5202
def delete_item(key):
    """"""
    CACHED_KEY_FILE = os.path.join(CURRENT_DIR, key)

    if os.path.isfile(CACHED_KEY_FILE):
        os.remove(CACHED_KEY_FILE)
431291
def delete(self):
        """"""
        if not self._sync:
            del self._buffer
        shutil.rmtree(self.cache_dir)
1100382
def _removeLru(self):
        
        (dataFile, handle) = self._cache.pop()
        handle.close()
        return dataFile
125522
def clear(self, match="*", count=1000):
        
        cursor = '0'
        pipe = self._client.pipeline(transaction=False)
        while cursor != 0:
            cursor, keys = self.scan(cursor=cursor, match=match, count=count)
            if keys:
                pipe.delete(*keys)
        pipe.hdel(self._bucket_key, self.key_prefix)
        pipe.execute()
        return True
180121
async def delete(self, key):
        
        try:
            async with self._client.delete(self.path_keys(key)) as r:
                if r.status not in [204, 404]:
                    return False
                return True
        except ContentEncodingError:
            """ Not error really """
            return True
        except:
            raise
1249598
function(key) {
  delete cache.mem[key];
  try {
    fs.unlinkSync(path.join(cache.basePath, key));
  }
  catch (e) {}
  removeRegistry(key);
  log.info(format('Removing cache entry %s', key));
}
1214948
def delete(self, key):
    '''
    '''
    self.cache_datastore.delete(key)
    self.child_datastore.delete(key)
991125
def removeSessionWithKey(self, key):
        
        self.store.query(
            PersistentSession,
            PersistentSession.sessionKey == key).deleteFromStore()
1260418
def delete(key)
      @cache.delete(key)
      File.delete(path_to(hash(key))) if disk_cache_enabled?
    end
731401
def delete(self, key):
        
        if not is_string(key):
            raise Exception("Key must be string")

        if len(key) > 32:
            raise Exception("Max key length is 32")

        old_root = copy.deepcopy(self.root_node)
        self.root_node = self._delete_and_delete_storage(
            self.root_node,
            bin_to_nibbles(to_string(key)))
        self.replace_root_hash(old_root, self.root_node)
9150
def remove(self, uid, filename=None):
        """"""
        if not filename:
            filename = self._filename
        elif filename not in self._reminders:
            return

        uid = uid.split('@')[0]

        with self._lock:
            rem = open(filename).readlines()
            for (index, line) in enumerate(rem):
                if uid == md5(line[:-1].encode('utf-8')).hexdigest():
                    del rem[index]
                    open(filename, 'w').writelines(rem)
                    break
85989
def delete(key, parameters = {})
      if File.file?(path = pathify(key, parameters))
        FileUtils.rm(path)
      end
    end
1370604
def unload_key(self, key):
        """"""
        key_hash = self._hash_for_key(key)
        if key in self:
            del self._cache[key_hash]