Add a list of features to the bag.

        Parameters
        ----------
        feature : :obj:`list` of :obj:`Feature`
            features to add
979302
def extend(self, features):
        
        self.features_.extend(features)
        self.num_features_ = len(self.features_)
809866
def add_object(self, obj):
        
        return self.add_bucket_key_data(obj._bucket._name, obj._key, None)
1312442
def superimpose(self, module):
        
        featuremonkey.compose(module, self._tasks)
        self._tasks.FEATURE_SELECTION.append(module.__name__)
900402
def register_features(with_features)
      Thread.new do
        features = []
        features = with_features.each do | feature |
          features.push(key: feature[:key],
                          variants: feature[:variants],
                          failoverVariant: feature[:failover_variant])
        end
        send_event 'Register Features', :put, '/api/sdk/v1/register', features
      end
    end
111147
def add(self, *items):
        
        for item in items:
            self.unsorted.append(item)
            key = item[0]
            self.index[key] = item
        return self
1008693
def add_features(self, **features):
        
        for fname, fvalue in six.iteritems(features):
            setattr(self, fname, fvalue)
            self.features.add(fname)
774620
def add_option(self, **options):
        
        for option, value in options.items():
            setattr(self, option, value)
            self._store_option(option)
981541
def add_object(self, obj):
        

        # delegate to SchemaType object
        schema_generator = self._get_generator_for_object(obj)
        schema_generator.add_object(obj)

        # return self for easy method chaining
        return self
845984
def append(self, obj):
        
        h = self.func(obj)

        self.list.append(obj)
        idx = len(self.list) - 1
        self.dict[h] = idx

        return idx
595318
def addvector(self, vec):
        
        vec.layer.ResetReading()
        for feature in vec.layer:
            self.layer.CreateFeature(feature)
        self.init_features()
        vec.layer.ResetReading()
383172
def add_object(self, obj):
        
        self.objects[obj.id] = obj
        self.all_objects[obj.id] = obj
        child_stack = list(obj.children)
        while child_stack:
            child = child_stack.pop()
            self.all_objects[child.id] = child
            child_stack.extend(getattr(child, "children", ()))
705102
def add_rmap_item(self, subj, pred, obj):
        
        def add_item(self, subj, pred, obj):
            try:
                self.rmap[obj][pred].append(subj)
            except KeyError:
                try:
                    self.rmap[obj][pred] = [subj]
                except KeyError:
                    self.rmap[obj] = {pred: [subj]}

        if isinstance(obj, list):
            for item in obj:
                add_item(self, subj, pred, item)
        else:
            add_item(self, subj, pred, obj)
1061656
def update_features(self, poly):
        """"""

        for feature in self.features:
            feature.wavelength = poly(feature.xpos)
1240547
def cli(ctx, feature={}, organism="", sequence=""):
    
    return ctx.gi.annotations.add_feature(feature=feature, organism=organism, sequence=sequence)
193289
def add_single_feature_methods(cls):
    
    # Sanity check: This only makes sense if we are building the GAPIC
    # subclass and have enums already attached.
    if not hasattr(cls, "enums"):
        return cls

    # Add each single-feature method to the class.
    for feature in cls.enums.Feature.Type:
        # Sanity check: Do not make a method for the falsy feature.
        if feature.name == "TYPE_UNSPECIFIED":
            continue

        # Assign the appropriate metadata to the function.
        detect = _create_single_feature_method(feature)

        # Assign a qualified name to the function, and perform module
        # replacement on the docstring.
        detect.__qualname__ = "{cls}.{name}".format(
            cls=cls.__name__, name=detect.__name__
        )
        detect.__doc__ = detect.__doc__.format(module=cls.__module__)

        # Place the function on the class being created.
        setattr(cls, detect.__name__, detect)

    # Done; return the class.
    return cls
90698
def add_model(self, model):
        
        if model.identity not in self._models.keys():
            self._models[model.identity] = model
        else:
            raise ValueError("{} has already been defined".format(model.identity))
995119
def add(self, **args):
        
        kwargs = self.getKwargs(args)
        if kwargs:
            self.model.add(**kwargs)