Delete the credential of an Object Storage Account.
968944
def cli(env, identifier, credential_id):
    """"""

    mgr = SoftLayer.ObjectStorageManager(env.client)
    credential = mgr.delete_credential(identifier, credential_id=credential_id)

    env.fout(credential)
163058
def delete(self, id):
        
        resp = self.client.accounts.delete(id)
        self.display(resp)
1286566
def credential_delete(self, *ids):
        
        return self.raw_query("credential", "delete", data={
            "credentials": [{"id": str(id)} for id in ids]
        })
905724
def revoke_oauth_credential(self):
        """"""
        if self.session.token_type == auth.SERVER_TOKEN_TYPE:
            return

        credential = self.session.oauth2credential
        revoke_access_token(credential)
299351
def delete_account(self, account):
        
        try:
            luser = self._get_account(account.username)
            groups = luser['groups'].load(database=self._database)
            for group in groups:
                changes = changeset(group, {})
                changes = group.remove_member(changes, luser)
                save(changes, database=self._database)

            delete(luser, database=self._database)
        except ObjectDoesNotExist:
            # it doesn't matter if it doesn't exist
            pass
753256
def auth_remove(name, drop, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('auth:group:remove', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
        'drop': drop,
    })
155905
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            adapter = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        cpc = adapter.manager.parent
        assert cpc.dpm_enabled
        adapter.manager.remove(adapter.oid)
801654
def cli(ctx):
    """"""
    dir_path = os.path.join(os.path.expanduser('~'), '.keep', '.credentials')
    if os.path.exists(dir_path):
        if click.confirm('[CRITICAL] Reset credentials saved in ~/.keep/.credentials ?', abort=True):
            os.remove(dir_path)
    utils.register()
88440
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            resource = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        resource.manager.remove(resource.oid)
657349
def remove_tls_credential(self, credentials):
        
        for cred in credentials:
            href = element_resolver(cred)
            if href in self.engine.server_credential:
                self.engine.server_credential.remove(href)
677838
def delete(self):
        """"""
        self._client.remove_object(self._instance, self._bucket, self.name)
877724
def remove_network_profile(self, obj, params):
        """"""

        self._logger.debug("delete profile: %s", params.ssid)
        str_buf = create_unicode_buffer(params.ssid)
        ret = self._wlan_delete_profile(self._handle, obj['guid'], str_buf)
        self._logger.debug("delete result %d", ret)
909522
public void api_credential_credentialId_DELETE(Long credentialId) throws IOException {
		String qPath = "/me/api/credential/{credentialId}";
		StringBuilder sb = path(qPath, credentialId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1288841
def delete(config, username, type):
        """"""
        client = Client()
        client.prepare_connection()
        user_api = API(client)
        user_api.delete(username, type)
207788
def _clear_xauth(self):
        '''
        
        '''
        os.remove(self._xauth_filename)
        for varname in ['AUTHFILE', 'XAUTHORITY']:
            if self._old_xauth[varname] is None:
                del os.environ[varname]
            else:
                os.environ[varname] = self._old_xauth[varname]
        self._old_xauth = None
343671
def remove(self):
        

        xmlrpc = XMLRPCConnection()
        try:
            xmlrpc.connection.remove_vrf(
                {
                    'vrf': { 'id': self.id },
                    'auth': self._auth_opts.options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        if self.id in _cache['VRF']:
            del(_cache['VRF'][self.id])
21415
def _delete(self):
        
        collection = JSONClientValidated('assessment',
                                         collection='AssessmentSection',
                                         runtime=self._runtime)
        collection.delete_one({'_id': ObjectId(self.get_id().get_identifier())})