Delete an attribute from a feature

Output:

    A standard apollo feature dictionary ({"features": [{...}]})
970949
def cli(ctx, feature_id, attribute_key, attribute_value, organism="", sequence=""):
    
    return ctx.gi.annotations.delete_attribute(feature_id, attribute_key, attribute_value, organism=organism, sequence=sequence)
420620
def deep_del(data, fn):
    
    result = {}

    for k, v in data.iteritems():
        if not fn(v):
            if isinstance(v, dict):
                result[k] = deep_del(v, fn)
            else:
                result[k] = v

    return result
970573
def unstructure_attrs_asdict(self, obj):
        # type: (Any) -> Dict[str, Any]
        """"""
        attrs = obj.__class__.__attrs_attrs__
        dispatch = self._unstructure_func.dispatch
        rv = self._dict_factory()
        for a in attrs:
            name = a.name
            v = getattr(obj, name)
            rv[name] = dispatch(v.__class__)(v)
        return rv
1199554
def remove(self, item):
        
        if item not in self.__dict__[self.ATTRIBUTES].keys():
            raise AttributeError('%s does not exist' % item)
        delattr(self, item)
868895
def _clean_dict(target_dict, whitelist=None):
    
    assert isinstance(target_dict, dict)
    return {
        ustr(k).strip(): ustr(v).strip()
        for k, v in target_dict.items()
        if v not in (None, Ellipsis, [], (), "")
        and (not whitelist or k in whitelist)
    }
1286561
def delete_attr(self, name: str, axis: int = 0) -> None:
		
		deprecated("'delete_attr' is deprecated. Use 'del ds.ra.key' or 'del ds.ca.key' instead")
		if axis == 0:
			del self.ra[name]
		else:
			del self.ca[name]
701907
def _strip_list_attributes(graph_):
    """"""
    for n_ in graph_.nodes(data=True):
        for k,v in n_[1].iteritems():
            if type(v) is list:
                graph_.node[n_[0]][k] = unicode(v)
    for e_ in graph_.edges(data=True):
        for k,v in e_[2].iteritems():
            if type(v) is list:
                graph_.edge[e_[0]][e_[1]][k] = unicode(v)

    return graph_
1355339
def delete_all(obj):
    ''''''
    types = tuple([
        Shader,
        Mesh,
        VertexBuffer,
        IndexBuffer,
        Texture,
        Program,
        Context,
    ])
    for name in dir(obj):
        child = getattr(obj, name)
        if isinstance(child, types):
            child.delete()
144184
def _imm_delattr(self, name):
    '''
    
    '''
    if _imm_is_persist(self):
        values = _imm_value_data(self)
        if name in values:
            dd = object.__getattribute__(self, '__dict__')
            if name in dd:
                del dd[name]
                if name in _imm_const_data(self): _imm_check(imm, [name])
        else:
            raise TypeError('Attempt to reset parameter \'%s\' of non-transient immutable' % name)
    else:
        return _imm_trans_delattr(self, name)
1264154
def remove_properties(self):
        
        if self.features_layer is not None:
            self.features_layer.remove_properties()

        if self.header is not None:
            self.header.remove_lp('features')
426489
def _clean_pivot_attributes(self, model):
        
        values = {}
        delete_keys = []

        for key, value in model.get_attributes().items():
            if key.find('pivot_') == 0:
                values[key[6:]] = value

                delete_keys.append(key)

        for key in delete_keys:
            delattr(model, key)

        return values
75388
def delete_attributes(self, attrs):
        
        assert(isinstance(attrs, list)), "Argument must be a list of names of keys to delete."
        self._manager.domain.delete_attributes(self.id, attrs)
        self.reload()
        return self
1167160
def cli(ctx, feature_id, db, accession, organism="", sequence=""):
    
    return ctx.gi.annotations.delete_dbxref(feature_id, db, accession, organism=organism, sequence=sequence)
1214987
function removeDuplicateAttributes(attrs) {
    var attrsNames = [],
        res = [];

    _.forEach(attrs, function (attr) {
        if (attrsNames.indexOf(attr.name) === -1) {
            res.push(attr);
            attrsNames.push(attr.name);
        }
    });

    return res;
}
447235
def cli(ctx, feature_id, organism="", sequence=""):
    
    return ctx.gi.annotations.delete_feature(feature_id, organism=organism, sequence=sequence)
368363
def remove_attributes(self, model):
        
        for child in model.children():
            if 'nn.modules.container' in str(type(child)):
                self.remove_attributes(child)
            else:
                try:
                    del child.x
                except AttributeError:
                    pass
                try:
                    del child.y
                except AttributeError:
                    pass
967863
def trim_and_pad_all_features(features, length):
  """"""
  return {k: _trim_and_pad(v, length) for k, v in features.items()}