Delete an Amazon SageMaker endpoint configuration.

        Args:
            endpoint_config_name (str): Name of the Amazon SageMaker endpoint configuration to delete.
172292
def delete_endpoint_config(self, endpoint_config_name):
        
        LOGGER.info('Deleting endpoint configuration with name: {}'.format(endpoint_config_name))
        self.sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
336726
private void destroyEndpointMBeans() {
        for (Map.Entry<String, ServiceRegistration<DynamicMBean>> mbean : endpointMBeans.entrySet()) {
            String mbeanName = mbean.getKey();
            endpointMBeans.remove(mbeanName);
            mbean.getValue().unregister();
        }
    }
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)
639811
public static ServerBootstrap removeConfiguration(ServerBootstrap b, String name) {
		Objects.requireNonNull(b, "bootstrap");
		Objects.requireNonNull(name, "name");
		if (b.config().childHandler() != null) {
			b.childHandler(removeConfiguration(b.config().childHandler(), name));
		}
		return b;
	}
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
1014855
def remove(self):
        
        LOGGER.debug("Endpoint.remove - " + self.id + " - " + self.url)
        if self.id is None:
            return None
        else:
            if self.id in EndpointService.local_cache_by_id:
                for search_params in EndpointService.local_cache_by_id[self.id]:
                    if search_params in EndpointService.local_cache_by_params.keys():
                        EndpointService.local_cache_by_params.pop(search_params)
                EndpointService.local_cache_by_id.pop(self.id)

            params = SessionService.complete_transactional_req({
                'ID': self.id
            })

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                params['OPERATION'] = 'deleteEndpoint'
                args = {'properties': params}
            else:
                args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}

            response = EndpointService.requester.call(args)

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                response = response.get()

            if response.rc != 0:
                LOGGER.warning(
                    'Endpoint.remove - Problem while deleting endpoint ' + str(self.id) +
                    'Reason: ' + str(response.response_content) + ' - ' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                if response.rc == 500 and ArianeMappingOverloadError.ERROR_MSG in response.error_message:
                    raise ArianeMappingOverloadError("Endpoint.remove",
                                                     ArianeMappingOverloadError.ERROR_MSG)
                # traceback.print_stack()
                return self
            else:
                if self.parent_node is not None:
                    self.parent_node.sync()
                return None
243784
def remove_parameter(self, name):
		
		spec = self.__specs[name] if name in self.__specs else None
		if spec is not None and spec.optional() is False:
			raise ValueError('Unable to remove a required parameter "%s"' % name)

		WURIQuery.remove_parameter(self, name)
259570
def endpoint_delete(service, region=None, profile=None, interface=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return {'Error': 'Could not find any endpoints for the service'}
    kstone.endpoints.delete(endpoint['id'])
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return True
46777
public void unregisterEndpoint(String endpointId) throws MgcpEndpointNotFoundException {
        MgcpEndpoint endpoint = this.endpoints.remove(endpointId);
        if (endpoint == null) {
            throw new MgcpEndpointNotFoundException("Endpoint " + endpointId + " not found");
        }
        endpoint.forget((MgcpMessageObserver) this);
        endpoint.forget((MgcpEndpointObserver) this);
        
        if (log.isDebugEnabled()) {
            log.debug("Unregistered endpoint " + endpoint.getEndpointId().toString() + ". Count: " + this.endpoints.size());
        }
    }
225091
def remove(name=None, index=None):
    

    removed = False
    count = 1
    for configuration in _CONFIG.sections():
        if index != None:
            if count == index:
                _CONFIG.remove_section(configuration)
                removed = True
                break

        if name != None:
            if configuration == name:
                _CONFIG.remove_section(configuration)
                removed = True
                break

        count += 1

    if not removed:
        raise JutException('Unable to find %s configuration' % name)

    with open(_CONFIG_FILEPATH, 'w') as configfile:
        _CONFIG.write(configfile)
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)
350509
def _build_endpoint(self, endpoint_name):
        
        endpoint_relative = settings.get('asmaster_endpoints', endpoint_name)
        return '%s%s' % (self.host, endpoint_relative)
1155036
public static function close($config_name)
    {
        if (isset(self::$instance[$config_name])) {
            self::$instance[$config_name]->closeConnection();
            self::$instance[$config_name] = null;
        }
    }
697486
def delete_command(endpoint_id, rule_id):
    
    client = get_client()

    res = client.delete_endpoint_acl_rule(endpoint_id, rule_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
316846
def purge(self, name=None):
        
        self.disconnect(name)

        if name in self._connections:
            del self._connections[name]
384383
def config_delete(args):
    
    r = fapi.delete_workspace_config(args.project, args.workspace,
                                        args.namespace, args.config)
    fapi._check_response_code(r, [200,204])
    return r.text if r.text else None
663611
def delete_website_configuration(self, headers=None):
        
        response = self.connection.make_request('DELETE', self.name,
                query_args='website', headers=headers)
        body = response.read()
        boto.log.debug(body)
        if response.status == 204:
            return True
        else:
            raise self.connection.provider.storage_response_error(
                response.status, response.reason, body)