Brutely clears the key value store for keys with THUMBNAIL_KEY_PREFIX
        prefix. Use this in emergency situations. Normally you would probably
        want to use the ``cleanup`` method instead.
483589
def clear(self):
        
        all_keys = self._find_keys_raw(settings.THUMBNAIL_KEY_PREFIX)
        if all_keys:
            self._delete_raw(*all_keys)
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
436762
def remove_custom_binding(self, key_name, needs_prefix=False):
        
        k = (needs_prefix, key_name)

        if k in self.custom_bindings:
            self.custom_key_bindings.remove(self.custom_bindings[k].handler)
            del self.custom_bindings[k]
131622
def _clear(self, pipe=None):
        
        redis = self.redis if pipe is None else pipe
        redis.delete(self.key)
860196
def clear(self):
        """"""
        for k in list(self.keys()):
            if k not in self.extrakeys:
                del self[k]
909241
def del_metadata_keys(self, bucket, label, keys):
        '''
        '''
        if self.mode !="r":
            try:
                payload = self._get_bucket_md(bucket)
            except OFSFileNotFound:
                # No MD found...
                raise OFSFileNotFound("Couldn't find a md file for %s bucket" % bucket)
            except OFSException as e:
                raise OFSException(e)
            if payload.has_key(label):
                for key in [x for x in keys if payload[label].has_key(x)]:
                    del payload[label][key]
            self.put_stream(bucket, MD_FILE, json.dumps(payload), params={}, replace=True, add_md=False)
        else:
            raise OFSException("Cannot update MD in archive in 'r' mode")
1291753
def _purge_config_file(self, key):
        
        state = self.__load_state()
        del state['remove_configs'][key]
        self.__dump_state(state)
962824
private void clearPrefOnBranchKeyChange() {
        // If stored key isn't the same as the current key, we need to clean up
        // Note: Link Click Identifier is not cleared because of the potential for that to mess up a deep link
        String linkClickID = getLinkClickID();
        String linkClickIdentifier = getLinkClickIdentifier();
        String appLink = getAppLink();
        String pushIdentifier = getPushIdentifier();
        prefsEditor_.clear();
        
        setLinkClickID(linkClickID);
        setLinkClickIdentifier(linkClickIdentifier);
        setAppLink(appLink);
        setPushIdentifier(pushIdentifier);
        prefHelper_.prefsEditor_.apply();
    }
805160
function deleteMetadataForEntry(self, key) {
			var iIndex = self._metadata.__byKey__[key];
			delete self._metadata.__byKey__[key];
			delete self._metadata.__byIndex__[iIndex];
			seekMetadataLRU(self);
		}
491085
def clear_cached_values(self):
        
        self._prof_interp = None
        self._prof_y = None
        self._prof_z = None
        self._marg_interp = None
        self._marg_z = None
        self._post = None
        self._post_interp = None
        self._interp = None
        self._ret_type = None
1036182
def delete_prefix(self, prefix):
        """"""
        delete_request = self._build_delete_request(
            prefix,
            range_end=utils.increment_last_byte(utils.to_bytes(prefix))
        )
        return self.kvstub.DeleteRange(
            delete_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )
43872
def clean_key(cls, key):
        
        for var_re in cls.VARIABLE_RES:
            key = var_re.sub('#', key)
        return key
448436
def clear_key_before(self, key, namespace=None, timestamp=None):
        """"""
        block_size = self.config.block_size
        if namespace is None:
            namespace = self.config.namespace
        if timestamp is not None:
            offset, remainder = divmod(timestamp, block_size)
            if remainder:
                raise ValueError('timestamp must be on a block boundary')
            if offset == 0:
                raise ValueError('cannot delete before offset zero')
            offset -= 1
            self.driver.clear_key_before(key, namespace, offset, timestamp)
        else:
            self.driver.clear_key_before(key, namespace)
1037427
def _cleanup_keys_with_confirmation(self, keys_to_delete):
    
    print('Round name: ', self.round_name)
    print('Number of entities to be deleted: ', len(keys_to_delete))
    if not keys_to_delete:
      return
    if self.verbose:
      print('Entities to delete:')
      idx = 0
      prev_key_prefix = None
      dots_printed_after_same_prefix = False
      for k in keys_to_delete:
        if idx >= 20:
          print('   ...')
          print('   ...')
          break
        key_prefix = (k.flat_path[0:1]
                      if k.flat_path[0] in [u'SubmissionType', u'WorkType']
                      else k.flat_path[0])
        if prev_key_prefix == key_prefix:
          if not dots_printed_after_same_prefix:
            print('   ...')
          dots_printed_after_same_prefix = True
        else:
          print('  ', k)
          dots_printed_after_same_prefix = False
          idx += 1
        prev_key_prefix = key_prefix
    print()
    inp = input_str('Are you sure? (type "yes" without quotes to confirm): ')
    if inp != 'yes':
      return
    with self.datastore_client.no_transact_batch() as batch:
      for k in keys_to_delete:
        batch.delete(k)
    print('Data deleted')
1310338
def pop_kwargs_with_prefix(prefix: str, kwargs: dict) -> dict:
    
    keys = [key for key in kwargs if key.startswith(prefix)]
    return {key[len(prefix):]: kwargs.pop(key) for key in keys}
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
998859
def flush(bank, key=None):
    '''
    
    '''
    if key is None:
        c_key = bank
    else:
        c_key = '{0}/{1}'.format(bank, key)
    try:
        return api.kv.delete(c_key, recurse=key is None)
    except Exception as exc:
        raise SaltCacheError(
            'There was an error removing the key, {0}: {1}'.format(
                c_key, exc
            )
        )