Delete an Amazon SageMaker ``Endpoint``.

        Raises:
            ValueError: If the endpoint does not exist.
180315
def delete_endpoint(self):
        
        self._ensure_latest_training_job(error_message='Endpoint was not created yet')
        self.sagemaker_session.delete_endpoint(self.latest_training_job.name)
74818
def delete(self, endpoint, params=None, version='1.1', json_encoded=False):
        """"""
        return self.request(endpoint, 'DELETE', params=params, version=version, json_encoded=json_encoded)
704651
def removePeer(self):
        
        self._openRepo()

        def func():
            self._updateRepo(self._repo.removePeer, self._args.url)
        self._confirmDelete("Peer", self._args.url, func)
336726
private void destroyEndpointMBeans() {
        for (Map.Entry<String, ServiceRegistration<DynamicMBean>> mbean : endpointMBeans.entrySet()) {
            String mbeanName = mbean.getKey();
            endpointMBeans.remove(mbeanName);
            mbean.getValue().unregister();
        }
    }
817084
def delete(self):
        
        _, r = self.machine.datacenter.request('DELETE', self.path)
        r.raise_for_status()
311984
def deleteEndpointSubscriptions(self,ep):
		'''
		
		'''
		result = asyncResult()
		result.endpoint = ep
		data = self._deleteURL("/subscriptions/"+ep)
		if data.status_code == 204: #immediate success
			result.error = False
			result.is_done = True
		else:
			result.error = response_codes("delete_endpoint_subscription",data.status_code)
			result.is_done = True
		result.raw_data = data.content
		result.status_code = data.status_code
		return result
221163
def delete_model(self):
        
        request_failed = False
        failed_models = []
        for model_name in self._model_names:
            try:
                self.sagemaker_session.delete_model(model_name)
            except Exception:  # pylint: disable=broad-except
                request_failed = True
                failed_models.append(model_name)

        if request_failed:
            raise Exception('One or more models cannot be deleted, please retry. \n'
                            'Failed models: {}'.format(', '.join(failed_models)))
256421
def delete_instance(model, instance_id, _commit=True):
    
    try:
        model = get_model(model)
    except ImportError:
        return

    instance = model.query.get(instance_id)
    if not instance:
        return

    db.session.delete(instance)
    try:
        if _commit:
            db.session.commit()
        else:
            db.session.flush()
    except Exception as exception:
        db.session.rollback()
        raise exception
256939
public String delete(String endpoint, String params) throws IOException {
        return this.delete(endpoint, params, "");
    }
282602
def _remove(self, client_kwargs):
        
        with _handle_client_error():
            # Object
            if 'Key' in client_kwargs:
                return self.client.delete_object(**client_kwargs)

            # Bucket
            return self.client.delete_bucket(Bucket=client_kwargs['Bucket'])
1183855
def unregister(self, entry_point):
        
        if entry_point not in self.registered_extensions:
            raise ValueError('Extension not registered')

        ep = EntryPoint.parse(entry_point)
        self.registered_extensions.remove(entry_point)
        if self._extensions_by_name is not None:
            del self._extensions_by_name[ep.name]
        for i, ext in enumerate(self.extensions):
            if ext.name == ep.name:
                del self.extensions[i]
                break
298454
def role_delete(role_id, endpoint_id):
    
    client = get_client()
    res = client.delete_endpoint_role(endpoint_id, role_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
536945
def delete(self, robj, rw=None, r=None, w=None, dw=None, pr=None,
               pw=None, timeout=None):
        
        raise NotImplementedError
200142
def _clear_dict(endpoint_props):
    '''
    
    '''
    return dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(endpoint_props)
        if prop_val is not None
    )
934031
public Response delete(String endpoint) {
        return call(Method.DELETE, endpoint, null, null);
    }
748012
def owns_endpoint(self, endpoint):
        

        if self.blueprint:
            if endpoint.startswith(self.blueprint.name):
                endpoint = endpoint.split(self.blueprint.name + '.', 1)[-1]
            else:
                return False
        return endpoint in self.endpoints
112358
def delete(self, endpoint, **kwargs):
        
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)