RESTful endpoint for deleting an API key.
420458
@DELETE
    @Path("{id}")
    public SuccessResponse deleteApiKey(@PathParam("id") String id, @Authenticated Subject subject) {
        _uac.deleteApiKey(subject, id);
        return SuccessResponse.instance();
    }
227863
def delete_simple_httpauth_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(HTTPAuthReadAPI, database_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Simple HTTP Auth Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
308439
def rest_delete(url, timeout, show_error=False):
    ''''''
    try:
        response = requests.delete(url, timeout=timeout)
        return response
    except Exception as exception:
        if show_error:
            print_error(exception)
        return None
636422
def delete(self, resource_id):
        

        endpoint = '{}/{}'.format(self.endpoint, resource_id)

        response = self.api.execute("DELETE", endpoint)

        if not response.ok:
            raise Error.parse(response.json())

        return self._cls.parse(response.json())
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
670688
def delete_simple_public_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(PublicReadAPI, database_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Simple Public Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
1329689
def delete_service_key(self, service_name, key_name):
        
        key = self.get_service_key(service_name, key_name)
        logging.info("Deleting service key %s for service %s" % (key, service_name))
        return self.api.delete(key['metadata']['url'])
112358
def delete(self, endpoint, **kwargs):
        
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)
39104
def delete_api_model(restApiId, modelName, region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        conn.delete_model(restApiId=restApiId, modelName=modelName)
        return {'deleted': True}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
1308455
def delete(self, endpoint: str, **kwargs) -> dict:
        """"""

        return self._request('DELETE', endpoint, **kwargs)
499934
def delete_api_method_response(restApiId, resourcePath, httpMethod, statusCode,
                               region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        resource = describe_api_resource(restApiId, resourcePath, region=region,
                                         key=key, keyid=keyid, profile=profile).get('resource')
        if resource:
            conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
            conn.delete_method_response(restApiId=restApiId, resourceId=resource['id'],
                                        httpMethod=httpMethod, statusCode=str(statusCode))  # future lint: disable=blacklisted-function
            return {'deleted': True}
        return {'deleted': False, 'error': 'no such resource'}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
639351
async def delete(self, request, resource=None, **kwargs):
        """"""
        if resource is None:
            raise RESTNotFound(reason='Resource not found')
        self.collection.remove(resource)
1155981
def delete_api_key(apiKey, region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        conn.delete_api_key(apiKey=apiKey)
        return {'deleted': True}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
932308
def invalidate_api_key(self, body, params=None):
        
        if body in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'body'.")
        return self.transport.perform_request(
            "DELETE", "/_security/api_key", params=params, body=body
        )
14677
def delete_api_deployment(restApiId, deploymentId, region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        conn.delete_deployment(restApiId=restApiId, deploymentId=deploymentId)
        return {'deleted': True}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
180121
async def delete(self, key):
        
        try:
            async with self._client.delete(self.path_keys(key)) as r:
                if r.status not in [204, 404]:
                    return False
                return True
        except ContentEncodingError:
            """ Not error really """
            return True
        except:
            raise
877612
def client_delete(self, url, **kwargs):
        """"""
        response = requests.delete(self.make_url(url), headers=self.headers)
        if not response.ok:
            raise Exception(
                '{status}: {reason}.\nCircleCI Status NOT OK'.format(
                    status=response.status_code, reason=response.reason))
        return response.json()