:return: list of members as name, type tuples
        :rtype: list
515813
def getmembers(self):
        
        return filter(
            lambda m: not m[0].startswith("__") and not inspect.isfunction(m[1]) and not inspect.ismethod(m[1]),
            inspect.getmembers(self.__class__)
        )
1000469
def tuple(self):
        
        return tuple(getattr(self, k) for k in self.__class__.defaults)
307560
def list_members(self, list_id):
        
        return [User(user._json) for user in self._client.list_members(list_id=list_id)]
1223497
def list_lbaas_members(self, lbaas_pool, retrieve_all=True, **_params):
        """"""
        return self.list('members', self.lbaas_members_path % lbaas_pool,
                         retrieve_all, **_params)
24337
def members(name, members_list, root=None):
    '''
    
    '''
    cmd = 'chgrpmem -m = {0} {1}'.format(members_list, name)
    retcode = __salt__['cmd.retcode'](cmd, python_shell=False)

    return not retcode
973196
def astuple(self):
        
        return tuple(getattr(self, f.name) for f in fields(self))
1283515
def getmembers(self):
        
        self._check()
        if not self._loaded:    # if we want to obtain a list of
            self._load()        # all members, we first have to
                                # scan the whole archive.
        return self.members
615299
def _member_defs(self):
        
        members = self._clsdict['__members__']
        member_defs = [
            self._member_def(member) for member in members
            if member.name is not None
        ]
        return '\n'.join(member_defs)
286420
def host_members(self):
        '''
        '''
        host = self.host()
        if host is None:
            return
        for member, full_member in host.members_objects:
            yield full_member
193892
def members(self):
        ''''''
        with self._mutex:
            if not self._members:
                self._members = {}
                for o in self.organisations:
                    # TODO: Search for these in the tree
                    self._members[o.org_id] = o.obj.get_members()
        return self._members
170024
def names(self):
        
        result = []
        for key, value in self.iteritems():
            if value & self.bitmask:
                result.append(key)
        return result
253034
def members(self):
        
        return list(
            [
                self.children_class(child)
                for child in self.graph.subjects(RDF_NAMESPACES.DTS.parent, self.asNode())
            ]
        )
34798
def prior_model_name_constant_tuples_dict(self):
        
        return {name: list(prior_model.constant_tuples) for name, prior_model in self.prior_model_tuples}
775287
def keys(self):
        

        keys = list()

        for attribute_name, type_instance in inspect.getmembers(self):

            # ignore parameters with __ and if they are methods
            if attribute_name.startswith('__') or inspect.ismethod(type_instance):

                continue

            keys.append(attribute_name)

        return keys
142840
def list_members(self, retrieve_all=True, **_params):
        """"""
        # Pass filters in "params" argument to do_request
        return self.list('members', self.members_path, retrieve_all,
                         **_params)
1142480
def members(self):
        
        if self._members is None:
            self._members = MemberList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._members
905357
def get_members(self, role=github.GithubObject.NotSet):
        
        assert role is github.GithubObject.NotSet or isinstance(role, (str, unicode)), role
        url_parameters = dict()
        if role is not github.GithubObject.NotSet:
            assert role in ['member', 'maintainer', 'all']
            url_parameters["role"] = role
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            self.url + "/members",
            url_parameters
        )