Get all the members in a set.
434894
def smembers(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'SMEMBERS', key, encoding=encoding)
867203
def get_project_members(self):
        """"""

        r = self._request('members/')
        if not r:
            return None

        retour = []

        for data in r.json()['members']:
            # Base properties
            u = User()
            u.__dict__.update(data)

            retour.append(u)

        return retour
190058
def visit_set(self, node):
        """"""
        return "{%s}" % ", ".join(child.accept(self) for child in node.elts)
636459
public static boolean containsAll(Set<String> target, Set<String> members) {
		target = new HashSet<String>(target);
		target.retainAll(members);
		return target.size() == members.size();
	}
484676
def intersection(self, key, *others):
        """"""
        if not isinstance(key, str):
            raise ValueError("String expected.")
        self.db.sinterstore(key, [self.key] + [o.key for o in others])
        return Set(key)
283936
def sets(self):
        """"""
        sets = {}
        for x in self._parents:
            sets.setdefault(self[x], set()).add(x)
        return frozenset(frozenset(v) for v in six.viewvalues(sets))
281129
public Set<User> findAllMembers(Iterable<Name> absoluteIds) {
        return Sets.newLinkedHashSet(userRepo.findAll(toRelativeIds(absoluteIds)));
    }
202335
def _get_replica_set_members(self, selector):
        """"""
        # Implemented here in Topology instead of MongoClient, so it can lock.
        with self._lock:
            topology_type = self._description.topology_type
            if topology_type not in (TOPOLOGY_TYPE.ReplicaSetWithPrimary,
                                     TOPOLOGY_TYPE.ReplicaSetNoPrimary):
                return set()

            return set([sd.address for sd in selector(self._new_selection())])
500390
def get_grouped(self, go_ntsets, go_all, gosubdag, **kws):
        """"""
        kws_grpd = {k:v for k, v in kws.items() if k in Grouped.kws_dict}
        kws_grpd['go2nt'] = self._init_go2ntpresent(go_ntsets, go_all, gosubdag)
        return Grouped(gosubdag, self.godag.version, **kws_grpd)
1217247
def get_record_sets(record):
    """"""
    # get lists of sets with search_pattern equals to None but already in the
    # set list inside the record
    record_sets = set(record.get('_oai', {}).get('sets', []))
    for spec in _build_cache():
        if spec in record_sets:
            yield spec

    # get list of sets that match using percolator
    index, doc_type = RecordIndexer().record_to_index(record)
    document = record.dumps()

    percolator_doc_type = _get_percolator_doc_type(index)
    _create_percolator_mapping(index, percolator_doc_type)
    results = _percolate_query(index, doc_type, percolator_doc_type, document)
    prefix = 'oaiset-'
    prefix_len = len(prefix)
    for match in results:
        set_name = match['_id']
        if set_name.startswith(prefix):
            name = set_name[prefix_len:]
            yield name

    raise StopIteration
459304
def owners(self):
        """"""
        result = set()
        for role in self._OWNER_ROLES:
            for member in self._bindings.get(role, ()):
                result.add(member)
        return frozenset(result)
1336618
def get_all(cls):
        '''  '''
        redis = cls.get_redis()

        return list(map(
            lambda id: cls.get(id),
            map(
                debyte_string,
                redis.smembers(cls.members_key())
            )
        ))
490541
def members(self):
        
        if self._members is None:
            self._members = Feed(self.links["members"], pypump=self._pump)
        return self._members
631262
def members(self):
        
        if self._members is None:
            self.assert_bind_client()
            self._members = self.bind_client.get_club_members(self.id)
        return self._members
1274143
def get_user_sets(client_id, user_id):
    """"""
    data = api_call('get', 'users/{}/sets'.format(user_id), client_id=client_id)
    return [WordSet.from_dict(wordset) for wordset in data]
1342767
def _get_members(o):
    
    result = []
    for n in dir(o):
        if hasattr(o, n) and n not in ["__globals__", "func_globals"]:
            result.append((n, getattr(o, n)))
    return result
1062131
def mget(self, *keys):
        
        keys = list(map(self.get_key, keys))
        return list(map(self._loads, self._client.mget(*keys)))