Return list of automation members
        :param offset: Pagination offset.
        :param limit: Pagination limit.
        :param api: sevenbridges Api instance.
        :return: AutomationMember collection
3194
def get_members(self, offset=None, limit=None, api=None):
        
        api = api or self._API
        return AutomationMember.query(
            automation=self.id, offset=offset, limit=limit, api=api
        )
662304
def get_members(self, filter_=github.GithubObject.NotSet,
                    role=github.GithubObject.NotSet):
        
        assert (filter_ is github.GithubObject.NotSet or
                isinstance(filter_, (str, unicode))), filter_
        assert (role is github.GithubObject.NotSet or
                isinstance(role, (str, unicode))), role

        url_parameters = {}
        if filter_ is not github.GithubObject.NotSet:
            url_parameters["filter"] = filter_
        if role is not github.GithubObject.NotSet:
            url_parameters["role"] = role
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            self.url + "/members",
            url_parameters
        )
1055843
def get_members(self, offset=None, limit=None):
        
        extra = {
            'resource': self.__class__.__name__,
            'query': {'id': self.id}
        }
        logger.info('Get team members', extra=extra)
        response = self._api.get(
            url=self._URL['members_query'].format(id=self.id),
            params={'offset': offset, 'limit': limit}
        )
        data = response.json()
        total = response.headers['x-total-matching-query']
        members = [TeamMember(api=self._api, **member) for member in
                   data['items']]
        links = [Link(**link) for link in data['links']]
        href = data['href']
        return Collection(resource=TeamMember, href=href, total=total,
                          items=members, links=links, api=self._api)
835965
def get_members(self, selector):
        
        members = []
        for member in self.get_member_list():
            if selector.select(member):
                members.append(member)

        return members
582657
def get_all_names( self, offset=None, count=None, include_expired=False ):
        
        if offset is not None and offset < 0:
            offset = None

        if count is not None and count < 0:
            count = None 

        cur = self.db.cursor()
        names = namedb_get_all_names( cur, self.lastblock, offset=offset, count=count, include_expired=include_expired )
        return names
304887
def members(self):
        
        member_list_request = etcdrpc.MemberListRequest()
        member_list_response = self.clusterstub.MemberList(
            member_list_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )

        for member in member_list_response.members:
            yield etcd3.members.Member(member.ID,
                                       member.name,
                                       member.peerURLs,
                                       member.clientURLs,
                                       etcd_client=self)
394735
def get(self, limit=None, page=None):
        
        has_more = False
        self.bounds.paginate = True
        limit_paginate, offset = self.bounds.get(limit, page)
        self.default_val = []
        results = self._query('get')

        if limit_paginate:
            self.bounds.paginate = False
            if len(results) == limit_paginate:
                has_more = True
                results.pop(-1)

        it = ResultsIterator(results, orm_class=self.orm_class, has_more=has_more, query=self)
        return self.iterator_class(it)
855839
def get_action_list(self, page=1):
        
        kw = {}
        if page:
            kw['inum'] = page
        actions, _ = self._call('getactionlist', **kw)
        result_list = []
        for action in actions:
            result_list.append(ActionInList.object_from_api(action))
        return result_list
926992
def select_page(self, limit, offset=0, **kwargs):
        
        start = offset
        while True:
            result = self.select(limit=[start, limit], **kwargs)
            start += limit
            if result:
                yield result
            else:
                break
            if self.debug:
                break
129389
def list_records(self, limit=None, offset=None):
        
        return self.manager.list_records(self, limit=limit, offset=offset)
1318868
def list_(*, cursor: str=None,
          exclude_archived: bool=None,
          exclude_members: bool=None,
          limit: int=None) -> snug.Query[Page[t.List[Channel]]]:
    """"""
    kwargs = {
        'exclude_archived': exclude_archived,
        'exclude_members':  exclude_members,
        'limit':            limit
    }
    response = yield {'cursor': cursor, **kwargs}
    try:
        next_cursor = response['response_metadata']['next_cursor']
    except KeyError:
        next_query = None
    else:
        next_query = list_(**kwargs, cursor=next_cursor)
    return Page(
        load_channel_list(response['channels']),
        next_query=next_query,
    )
803869
def get_tasks(self, status=None, offset=None, limit=None):
        
        params = {'project': self.id, 'offset': offset, 'limit': limit}
        if status:
            params['status'] = status
        return self._api.tasks.query(api=self._api, **params)
764113
def listMembers(self, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member"
        return self.client.get(uri, None, headers, query_params, content_type)
1334830
def members(self):
        """"""
        result = list()
        for member in self.run_command(command="replSetGetStatus", is_eval=False)['members']:
            result.append({
                "_id": member['_id'],
                "host": member["name"],
                "server_id": self._servers.host_to_server_id(member["name"]),
                "state": member['state']
            })
        return result
229998
def get_joined_members(self, force_resync=False) -> List[User]:
        
        if force_resync:
            response = self.client.api.get_room_members(self.room_id)
            for event in response['chunk']:
                if event['content']['membership'] == 'join':
                    user_id = event["state_key"]
                    if user_id not in self._members:
                        self._mkmembers(
                            User(
                                self.client.api,
                                user_id,
                                event['content'].get('displayname'),
                            ),
                        )
        return list(self._members.values())
476237
def remove_member(self, user, api=None):
        
        api = api or self._API
        AutomationMember.remove(automation=self.id, user=user, api=api)
234576
def get_subscriptions(self, limit=100, offset=0, params={}):
        
        url = self.SUBSCRIPTIONS_URL + "?limit=%s&offset=%s" % (limit, offset)

        for key, value in params.items():
            if key is 'ids':
                value = ",".join(value)

            url += '&%s=%s' % (key, value)

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.get_request()