Add one or more members to a set.
339306
def sadd(self, key, member, *members):
        """"""
        return self.execute(b'SADD', key, member, *members)
278880
def _add_member(self, member):
        
        if member.id in self.children:
            return None
        else:
            self.children[member.id] = member
952194
public void addMembership(Membership membership) throws RedmineException {
		final Project project = membership.getProject();
		if (project == null)
			throw new IllegalArgumentException("Project must be set");
		if (membership.getUser() == null)
			throw new IllegalArgumentException("User must be set");
		transport.addChildEntry(Project.class, getProjectKey(project),
				membership);
	}
991205
public <S extends SortedGrouping<?>> void add(int id, S set) {
		cacheSetType(id, SetType.SORTED_GROUPING);
		sortedGroupings.put(id, set);
	}
3716
public void addSet(final SortedSet<T> set) {
        SortedMap<T, UBNode<T>> nodes = rootNodes;
        UBNode<T> node = null;
        for (T element : set) {
            node = nodes.get(element);
            if (node == null) {
                node = new UBNode<>(element);
                nodes.put(element, node);
            }
            nodes = node.children();
        }
        if (node != null) {
            node.setEndSet(set);
        }
    }
836385
def add_to_subset(self, id, s):
        
        n = self.node(id)
        if 'meta' not in n:
            n['meta'] = {}
        meta = n['meta']
        if 'subsets' not in meta:
            meta['subsets'] = []
        meta['subsets'].append(s)
919970
def _add_complex(self, members, is_association=False):
        """"""
        params = {'color': '#0000ff',
                  'arrowhead': 'dot',
                  'arrowtail': 'dot',
                  'dir': 'both'}
        for m1, m2 in itertools.combinations(members, 2):
            if self._has_complex_node(m1, m2):
                continue
            if is_association:
                m1_key = _get_node_key(m1.concept)
                m2_key = _get_node_key(m2.concept)
            else:
                m1_key = _get_node_key(m1)
                m2_key = _get_node_key(m2)
            edge_key = (set([m1_key, m2_key]), 'complex')
            if edge_key in self.existing_edges:
                return
            self.existing_edges.append(edge_key)
            self._add_edge(m1_key, m2_key, **params)
944514
def update_member(self, member, body=None):
        """"""
        return self.put(self.member_path % (member), body=body)
183894
def add(self, resource, replace=False):
        """"""
        uri = resource.uri
        if (uri in self and not replace):
            raise ResourceSetDupeError(
                "Attempt to add resource already in this set")
        self[uri] = resource
749003
def add(self, items):
        """"""
        options = self._create_options(items)
        for k, v in options.items():
            if k in self.labels and v not in self.items:
                options.pop(k)
                count = 0
                while f'{k}_{count}' in self.labels:
                    count += 1
                options[f'{k}_{count}'] = v
        self.widget.options.update(options)
        self.widget.param.trigger('options')
        self.widget.value = list(options.values())[:1]
1331694
def add(self, member, score):
        """"""
        return self.client.zadd(self.name, member, score)
1281697
def _Members(self, group):
    """"""
    group.members = set(group.members).union(self.gids.get(group.gid, []))
    return group
466371
def add(self, item):
        """"""
        if item in self._set:
            self._fifo.remove(item)
        elif len(self._set) == self.max_items:
            self._set.remove(self._fifo.pop(0))
        self._fifo.append(item)
        self._set.add(item)
902563
def member_add(self, cluster_id, params):
        """"""
        cluster = self._storage[cluster_id]
        result = cluster.member_add(params.get('id', None), params.get('shardParams', {}))
        self._storage[cluster_id] = cluster
        return result
247504
def add2set(self, pid, key, value):
    """"""
    prop = self.property_entries[pid]

    current = prop.objects.get(key, None)
    current_local_key = prop.references.get(key, None)

    if current and current is not value:
        current.detach()

    if current_local_key is None:
        prop.references[key] = prop.next_free_key
        prop.next_free_key += 1

    prop.objects[key] = value

    if prop.parent.dir:
        ref = prop.index_ref_name(key)
        dir_entry = prop.parent.dir.get(ref)
        if dir_entry is None:
            dir_entry = prop.parent.dir.makedir(ref)
        if value.dir != dir_entry:
            value.attach(dir_entry)
        prop.mark_modified()
783840
public void addAll(Set<? extends E> set) {
		if(set.size()<=MAXIMUM_COMBINE_SIZE) {
			if(combined==null) combined = new HashSet<>(set);
			else combined.addAll(set);
		} else {
			added.add(set);
		}
	}
1201617
def increment(self, member, amount=1):
        """"""
        self._dict[member] += amount
        return self._dict[member]