`<https://www.elastic.co/guide/en/elasticsearch/reference/current/ilm-remove-policy.html>`_

        :arg index: The name of the index to remove policy on
6147
def remove_policy(self, index=None, params=None):
        
        return self.transport.perform_request(
            "POST", _make_path(index, "_ilm", "remove"), params=params
        )
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
412592
def delete(args):
    
    m = TemplateManager(args.hosts)
    m.delete(args.name)
64677
def delete_index(es, index_name: str):
    """"""

    if not index_name:
        log.warn("No index name given to delete")
        return None

    result = es.indices.delete(index=index_name)
    return result
526706
def delete_index(self, refresh=False, ignore=None):
        """"""
        es = connections.get_connection("default")
        index = self.__class__.search_objects.mapping.index
        doc_type = self.__class__.search_objects.mapping.doc_type
        es.delete(index, doc_type, id=self.pk, refresh=refresh, ignore=ignore)
652075
def delete(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.delete_policy_version(options)
      resp.data
    end
813453
def remove(self, *args):
        '''
        
        '''
        return Plan(reduce(lambda m,k: m.remove(k), args, self.nodes))
243955
def filter_indices(self, options, verbosity, *args, **kwargs):
        """"""
        index_name_map = {
            index.__class__.__name__: index
            for index in index_builder.indexes
        }

        # Process includes.
        if options['index']:
            indices = set(options['index'])
        else:
            indices = set(index_name_map.keys())

        # Process excludes.
        for index_name in options['exclude']:
            if index_name not in index_name_map:
                self.invalid_index(index_name)
                return

            indices.discard(index_name)

        # Execute action for each remaining index.
        for index_name in indices:
            try:
                index = index_name_map[index_name]
            except KeyError:
                self.invalid_index(index_name)
                return

            if verbosity > 0:
                self.stdout.write("Processing index '{}'...".format(index_name))
            self.handle_index(index, *args, **kwargs)
1248335
def _remove_from_index(index, obj):
    """"""
    try:
        index.value_map[indexed_value(index, obj)].remove(obj.id)
    except KeyError:
        pass
1256343
def removeTab(self, index):
        
        curr_index = self.currentIndex()
        items = list(self.items())

        item = items[index]
        item.close()
        if index <= curr_index:
            self._currentIndex -= 1
1213778
def delete_policy(self, policy):
        
        return self.manager.delete_policy(scaling_group=self, policy=policy)
1131106
def alias_absent(name, index):
    '''
    
    '''

    ret = {'name': name, 'changes': {}, 'result': True, 'comment': ''}

    try:
        alias = __salt__['elasticsearch.alias_get'](aliases=name, indices=index)
        if alias and alias.get(index, {}).get("aliases", {}).get(name, None) is not None:
            if __opts__['test']:
                ret['comment'] = 'Alias {0} for index {1} will be removed'.format(name, index)
                ret['changes']['old'] = alias.get(index, {}).get("aliases", {}).get(name, {})
                ret['result'] = None
            else:
                ret['result'] = __salt__['elasticsearch.alias_delete'](aliases=name, indices=index)
                if ret['result']:
                    ret['comment'] = 'Successfully removed alias {0} for index {1}'.format(name, index)
                    ret['changes']['old'] = alias.get(index, {}).get("aliases", {}).get(name, {})
                else:
                    ret['comment'] = 'Failed to remove alias {0} for index {1} for unknown reasons'.format(name, index)
        else:
            ret['comment'] = 'Alias {0} for index {1} is already absent'.format(name, index)
    except Exception as err:
        ret['result'] = False
        ret['comment'] = six.text_type(err)

    return ret
1199622
def remove_hash_prefix_indices(self, threat_list, indices):
        """"""
        batch_size = 40
        q = '''DELETE FROM hash_prefix
                WHERE threat_type=? AND platform_type=? AND threat_entry_type=? AND value IN ({})
        '''
        prefixes_to_remove = self.get_hash_prefix_values_to_remove(threat_list, indices)
        with self.get_cursor() as dbc:
            for i in range(0, len(prefixes_to_remove), batch_size):
                remove_batch = prefixes_to_remove[i:(i + batch_size)]
                params = [
                    threat_list.threat_type,
                    threat_list.platform_type,
                    threat_list.threat_entry_type
                ] + [sqlite3.Binary(b) for b in remove_batch]
                dbc.execute(q.format(','.join(['?'] * len(remove_batch))), params)
181539
def delete_policy(self, scaling_group, policy):
        
        return self._manager.delete_policy(scaling_group=scaling_group,
                policy=policy)
143123
def _delete_doc_from_index(index_writer, docid):
        
        query = whoosh.query.Term("docid", docid)
        index_writer.delete_by_query(query)
1293470
def delete_index(index):
    """"""
    logger.info("Deleting search index: '%s'", index)
    client = get_client()
    return client.indices.delete(index=index)
134645
def delete_alias(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.delete_alias(index=self._name, **kwargs)