Delete index information from params

    Parameters
    ----------
    params : dict

    Returns
    -------
    result : dict
543448
def _split_index(params):
    
    result = {}
    for key in params:
        if isinstance(params[key], dict):
            value = params[key]['_value']
        else:
            value = params[key]
        result[key] = value
    return result
1256365
def remove_terms_by_indices(self, idx_to_delete_list):
        '''
        
        '''
        new_X, new_term_idx_store = self._get_X_after_delete_terms(idx_to_delete_list)
        return self._make_new_term_doc_matrix(new_X, self._mX, self._y, new_term_idx_store, self._category_idx_store,
                                              self._metadata_idx_store, self._y == self._y)
1098846
def delete(url, params={}, options={})
      response = connection.delete do |req|
        req.saddle_options = options
        req.url(url, params)
      end
      handle_response(response)
    end
1293470
def delete_index(index):
    """"""
    logger.info("Deleting search index: '%s'", index)
    client = get_client()
    return client.indices.delete(index=index)
705746
def update_params(params, updates):
    ''''''
    params = params.copy() if isinstance(params, dict) else dict()
    params.update(updates)
    return params
1330884
def remove(self, index):
        
        data = self.data
        index = self._split(index)
        for j, c in enumerate(index):
            i = int(c) - 1
            if j + 1 == len(index):
                try:
                    del data[i]
                except IndexError:
                    raise NoItemError('.'.join(index))
            else:
                data = data[i][4]
804636
def remove_index_from_handle(handle_with_index):
    '''
    
    '''

    split = handle_with_index.split(':')
    if len(split) == 2:
        split[0] = int(split[0])
        return split
    elif len(split) == 1:
        return (None, handle_with_index)
    elif len(split) > 2:
        raise handleexceptions.HandleSyntaxError(
            msg='Too many colons',
            handle=handle_with_index,
            expected_syntax='index:prefix/suffix')
552567
def delete index
      current = @first
      index.times do
        current = current.next
      end
      current.previous.next = current.next
      current.next.previous = current.previous
    end
680989
def delete(self, index=None):
        
        if index is None:
            javabridge.call(self.jobject, "delete", "()V")
        else:
            javabridge.call(self.jobject, "delete", "(I)V", index)
1156623
def _process_params(self, params):
        
        new_params = OrderedDict()
        for param_name, param_value in sorted(params.items()):
            param_value = params[param_name]
            ParamClass = AirtableParams._get(param_name)
            new_params.update(ParamClass(param_value).to_param_dict())
        return new_params
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
582570
def filter_params(params):
    
    if params is not None:
        new_params = copy.deepcopy(params)
        new_params = dict((k, v) for k, v in new_params.items() if v is not None)
        for key, value in new_params.items():
            if isinstance(value, bool):
                new_params[key] = "true" if value else "false"
        return new_params
1155965
def DeleteIndex(self, index):
        
        to_remove = None
        for i in self.Items:
            if i.index == index:
                to_remove = i

        if to_remove:
            self.Items.remove(to_remove)
892536
function replace_params(params) {
	return function replace_params_(match, key) {
		if(params && params.hasOwnProperty(key)) {
			var value = params[key];
			delete params[key];
			return value;
		}
		return ':' + key;
	};
}
689711
def delete(self, params, args, data):
        # type: (str, dict, dict) -> None
        
        ctx = self._create_context(params, args, data)
        row_id = ctx.get_row_id()

        if row_id is not None:
            return self._delete_one(row_id, ctx)
        else:
            return self._delete_collection(ctx)
1231319
def delete_index(self):
        
        es = self._init_connection()
        if es.indices.exists(index=self.index):
            es.indices.delete(index=self.index)
818911
def delete_by_query!(query, params = nil, request_options = {})
      res = delete_by_query(query, params, request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options) if res
      res
    end