Remove keys from the public or secret keyrings.

        :param keys: Single key ID or list of mutiple IDs
        :param secret: Delete secret keys
        :rtype: DeleteResult
450
def delete_keys(self, keys, secret=False):
        '''
        
        '''
        return self.execute(
            DeleteResult(),
            ['--batch', '--yes', '--delete-secret-key' if secret else '--delete-key'] + list(make_list(keys))
        )
36331
def delete_den(self):
        '''
        
        '''
        keys = self.list_keys()
        for status, keys in six.iteritems(self.list_keys()):
            for key in keys[self.DEN]:
                try:
                    os.remove(os.path.join(self.opts['pki_dir'], status, key))
                    eload = {'result': True,
                             'act': 'delete',
                             'id': key}
                    self.event.fire_event(eload,
                                          salt.utils.event.tagify(prefix='key'))
                except (OSError, IOError):
                    pass
        self.check_minion_cache()
        return self.list_keys()
965311
def _prune(current, keys):
    
    pruned_current = {k: current[k] for k in keys if k in current}
    pruned_children = list(
        filter(
            None, [_prune(c, keys) for c in current.get("IORegistryEntryChildren", [])]
        )
    )
    keep_current = any(k in current for k in keys) or pruned_children
    if keep_current:
        if pruned_children:
            pruned_current["IORegistryEntryChildren"] = pruned_children
        return pruned_current
    else:
        return {}
674978
def delete(self, key):
        """"""
        if self.servers:
            key = self._qualified_key(key)
            hashed_key = self.key_hasher(key)
            self.client.delete(hashed_key)
1142859
def filter_keys(cls, data):
        
        keys = list(data.keys())
        for pattern in cls.EXCLUDE_PATTERNS:
            for key in keys:
                if re.match(pattern, key):
                    keys.remove(key)
        return dict(filter(lambda x: x[0] in keys, data.items()))
290132
def _remove_refs(self, keys):
        
        # remove direct refs
        for key in keys:
            del self.relations[key]
        # then remove all entries from each child
        for cached in self.relations.values():
            cached.release_references(keys)
301134
def forget(self, *keys):
        
        keys = reversed(sorted(keys))

        for key in keys:
            del self[key]

        return self
353768
def remove_kv_store(self, key):
        
        data = {
            'operation': 'DELETE',
            'key': key
        }
        return self.post(self.make_url("/useragent-kv"), data=to_json(data),
                         headers=self.default_headers).text
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
814540
function remove(keys) {
  var self = this

  if (typeof keys === 'string') {
    self.map[keys] = undefined
  } else {
    removeAll(self.map, keys)
  }

  return self
}
642759
def keys_delete(cls, fqdn, key):
        """"""
        return cls.json_delete('%s/domains/%s/keys/%s' %
                               (cls.api_url, fqdn, key))
324472
public void deleteByKey(List<DatastoreKey> keys) {
    try {
      Key[] nativeKeys = new Key[keys.size()];
      for (int i = 0; i < keys.size(); i++) {
        nativeKeys[i] = keys.get(i).nativeKey();
      }
      nativeWriter.delete(nativeKeys);
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
768297
public Long del(String... keys) {
		try (Jedis jedis = getJedis()) {
			return jedis.del(keys);
		}
	}
1230944
def remove_reserved_keys(self, op):
        
        sanitized = {}
        reserved = {}
        
        for k in op.keys():
            if str(k) not in RESERVED_KEYS:
                sanitized[str(k)] = copy.deepcopy(op[k])
            else:
                reserved[str(k)] = copy.deepcopy(op[k])
                
        return sanitized, reserved
192488
def _remove_existing(self):
        
        for key in self._keys:
            if key in os.environ:
                LOG.debug('%r: removing old key %r', self, key)
                del os.environ[key]
        self._keys = []
851459
def delete_multi(self, keys):
        
        logger.debug('Deleting keys %r', keys)
        if six.PY2:
            msg = ''
        else:
            msg = b''
        for key in keys:
            msg += struct.pack(
                self.HEADER_STRUCT +
                self.COMMANDS['delete']['struct'] % len(key),
                self.MAGIC['request'],
                self.COMMANDS['delete']['command'],
                len(key), 0, 0, 0, len(key), 0, 0, str_to_bytes(key))

        msg += struct.pack(
            self.HEADER_STRUCT +
            self.COMMANDS['noop']['struct'],
            self.MAGIC['request'],
            self.COMMANDS['noop']['command'],
            0, 0, 0, 0, 0, 0, 0)

        self._send(msg)

        opcode = -1
        retval = True
        while opcode != self.COMMANDS['noop']['command']:
            (magic, opcode, keylen, extlen, datatype, status, bodylen, opaque,
             cas, extra_content) = self._get_response()
            if status != self.STATUS['success']:
                retval = False
            if status == self.STATUS['server_disconnected']:
                break

        return retval
1136157
def do_keys(self, keys):
        
        for inst in keys:
            typ = inst["kty"]
            try:
                _usage = harmonize_usage(inst['use'])
            except KeyError:
                _usage = ['']
            else:
                del inst['use']

            flag = 0
            for _use in _usage:
                for _typ in [typ, typ.lower(), typ.upper()]:
                    try:
                        _key = K2C[_typ](use=_use, **inst)
                    except KeyError:
                        continue
                    except JWKException as err:
                        logger.warning('While loading keys: {}'.format(err))
                    else:
                        if _key not in self._keys:
                            self._keys.append(_key)
                        flag = 1
                        break
            if not flag:
                logger.warning(
                    'While loading keys, UnknownKeyType: {}'.format(typ))