Delete the key from the key ring.
 If allow_secret is false, only public keys are deleted,
 otherwise secret keys are deleted as well.
175869
def delete_key(key, allow_secret = false)
      err = GPGME::gpgme_op_delete(self, key, allow_secret ? 1 : 0)
      exc = GPGME::error_to_exception(err)
      raise exc if exc
    end
718649
async def remove_ssh_key(self, user, key):
        
        key_facade = client.KeyManagerFacade.from_connection(self.connection())
        key = base64.b64decode(bytes(key.strip().split()[1].encode('ascii')))
        key = hashlib.md5(key).hexdigest()
        key = ':'.join(a + b for a, b in zip(key[::2], key[1::2]))
        await key_facade.DeleteKeys([key], user)
17817
async def delete(self, key):
        
        response = await self._discard(key)
        return response.body is True
1244266
def delete_node(self, key_chain):
        
        node = self._data
        for key in key_chain[:-1]:
            node = node[key]

        del node[key_chain[-1]]
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)
504748
def delete(self, key):
    '''
    '''
    self.logger.info('%s: delete %s' % (self, key))
    super(LoggingDatastore, self).delete(key)
366404
def delete(self, key):
        
        validate_is_bytes(key)

        self.root_hash = self._set(self.root_hash, encode_to_bin(key), b'')
578624
def remove(self, key):
        """"""
        if key in self.queue:
            del self.queue[key]
            self.write()
            return True
        return False
885199
def delete(name=None, group_id=None, region=None, key=None, keyid=None,
           profile=None, vpc_id=None, vpc_name=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    group = _get_group(conn, name=name, vpc_id=vpc_id, vpc_name=vpc_name,
                       group_id=group_id, region=region, key=key, keyid=keyid,
                       profile=profile)
    if group:
        deleted = conn.delete_security_group(group_id=group.id)
        if deleted:
            log.info('Deleted security group %s with id %s.', group.name, group.id)
            return True
        else:
            msg = 'Failed to delete security group {0}.'.format(name)
            log.error(msg)
            return False
    else:
        log.debug('Security group not found.')
        return False
642759
def keys_delete(cls, fqdn, key):
        """"""
        return cls.json_delete('%s/domains/%s/keys/%s' %
                               (cls.api_url, fqdn, key))
1114663
def delete(self):
        
        req = self.request(self.mist_client.uri+'/keys/'+self.id)
        req.delete()
        self.mist_client.update_keys()
582724
def delete(element_key)
      parameter = { basic_auth: @auth }
      response = self.class.delete("/elements/#{element_key}", parameter)
      unless response.success?
        puts "Could not save element: #{response.headers['x-errordescription']}"
      end
      response
    end
149019
def delete(self, key):
        
        obj = self._get_content()
        obj.pop(key, None)

        self.write_data(self.path, obj)
1844
def delete(key, parameters = {})
      @stores.map {|s| s.delete(key, parameters)}.any?
    end
1171036
def _regenerate_secret_key(self):
        
        # Don't regenerate the key if we have none
        if self._session and 'secret_key' in self._session:
            self._session['secret_key'] = (
                int(self._session['secret_key']) * 16807) % 2147483647
1362434
def remove(self, key, glob=False):
        """"""
        ns = self.namespace(key, glob)
        try:
            self.keyring.delete_password(ns, key)
        except PasswordDeleteError:  # OSX and gnome have no delete method 
            self.set(key, '', glob)
224660
def del_key(self, ref):
        
        if ref not in self.keys:
            response = self.request("client_del_key %s" % (ref))
            self.keys.remove(ref)
            if "success" in response:
                return None
            else:
                return response