Delete an existing Ceph keyring.
488340
def delete_keyring(service):
    """"""
    keyring = _keyring_path(service)
    if not os.path.exists(keyring):
        log('Keyring does not exist at %s' % keyring, level=WARNING)
        return

    os.remove(keyring)
    log('Deleted ring at %s.' % keyring, level=INFO)
1294591
def delete(key)
      header = self[key]
      @headers.reject! { |header| header.key == key } ? header : nil
    end
753927
def delete_entry(self, key):
        """"""
        pipe = self.client.pipeline()
        pipe.srem(self.keys_container, key)
        pipe.delete(key)
        pipe.execute()
195631
def remove(self, item, count=0):
        
        self._client.lrem(self.key_prefix, count, self._dumps(item))
674978
def delete(self, key):
        """"""
        if self.servers:
            key = self._qualified_key(key)
            hashed_key = self.key_hasher(key)
            self.client.delete(hashed_key)
1281014
def delete_from_index(self, key):
        ""
        old_value = self.data[key]
        keys = set(old_value.keys()).intersection(self.indexes.keys())
        for index_name in keys:
            if old_value[index_name] in self.indexes[index_name]:
                del self.indexes[index_name][old_value[index_name]]
415215
def deletesshkey(self, key_id):
        
        request = requests.delete(
            '{0}/{1}'.format(self.keys_url, key_id), headers=self.headers,
            verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.content == b'null':
            return False
        else:
            return True
668406
def delete(key, options = {})
      info = Utils.build_info(key, options)

      command "delete-generic-password",
        "-a", info[:account_name],
        "-s", info[:service_name],
        "-l", info[:label],
        "-D", info[:kind],
        "-C", info[:type]
    end
1023605
def delete(self, *args):
        """"""
        key = self.name_wid.text or self.name_wid.hint_text
        if not hasattr(self.store, key):
            # TODO feedback about missing key
            return
        delattr(self.store, key)
        try:
            return min(kee for kee in dir(self.store) if kee > key)
        except ValueError:
            return '+'
199529
def remove(self, key):
        '''
        
        '''
        encodedKey = json.dumps(key)
        sql = 'DELETE FROM ' + self.table + ' WHERE name = %s'
        with self.connect() as conn:
            with doTransaction(conn):
                return executeSQL(conn, sql, args=[encodedKey])
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
        )
332738
def _clean_ctx(self):
        
        try:
            if self.ctx is not None:
                self.__ctxcleanup(self.ctx)
                libcrypto.EVP_CIPHER_CTX_free(self.ctx)
                del self.ctx
        except AttributeError:
            pass
        self.cipher_finalized = True
1007783
def remove(self, key):
        
        payload = {
            key: {
                '__op': 'Delete'
                }
            }
        self.__class__.PUT(self._absolute_url, **payload)
        del self.__dict__[key]
862553
def delete_keypair(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        log.error(
            'The delete_keypair function must be called with -f or --function.'
        )
        return False

    if not kwargs:
        kwargs = {}

    if 'keyname' not in kwargs:
        log.error('A keyname is required.')
        return False

    params = {'Action': 'DeleteKeyPair',
              'KeyName': kwargs['keyname']}

    data = aws.query(params,
                     return_url=True,
                     location=get_location(),
                     provider=get_provider(),
                     opts=__opts__,
                     sigver='4')
    return data
663547
def keypair_delete(self, name):
        '''
        
        '''
        nt_ks = self.compute_conn
        nt_ks.keypairs.delete(name)
        return 'Keypair deleted: {0}'.format(name)
1163168
def delete(self, key, cas=0):
        
        server = self._get_server(key)
        return server.delete(key, cas)
1244266
def delete_node(self, key_chain):
        
        node = self._data
        for key in key_chain[:-1]:
            node = node[key]

        del node[key_chain[-1]]