ReadMembersOf.
        [Preview API]
        :param str member_id:
        :param str query_membership:
        :rtype: [str]
196914
def read_members_of(self, member_id, query_membership=None):
        
        route_values = {}
        if member_id is not None:
            route_values['memberId'] = self._serialize.url('member_id', member_id, 'str')
        query_parameters = {}
        if query_membership is not None:
            query_parameters['queryMembership'] = self._serialize.query('query_membership', query_membership, 'str')
        response = self._send(http_method='GET',
                              location_id='22865b02-9e4a-479e-9e18-e35b8803b8a0',
                              version='5.0-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('[str]', self._unwrap_collection(response))
819896
async def memberships(client: Client, search: str) -> dict:
    
    return await client.get(MODULE + '/memberships/%s' % search, schema=MEMBERSHIPS_SCHEMA)
242769
def from_node(index, name, session, data):
        
        if data.startswith('postgres'):
            conn_url, api_url = parse_connection_string(data)
            data = {'conn_url': conn_url, 'api_url': api_url}
        else:
            try:
                data = json.loads(data)
            except (TypeError, ValueError):
                data = {}
        return Member(index, name, session, data)
3376
def member_info(self, member_id):
        """"""
        info = self._shards[member_id].copy()
        info['id'] = member_id
        info['tags'] = self.tags.get(member_id, list())
        return info
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)
975367
def get_members(self, sort='id_asc'):
        
        return self._session.fetch_items("groups.getMembers", User.from_json, 1000, group_id=self.id, sort=sort, fields=User.__slots__ + User.USER_FIELDS)
314040
def list_subscribers(self, list_id):
        
        return [User(user._json) for user in self._client.list_subscribers(list_id=list_id)]
818421
def member(self, user, objects=False):
        
        try:
            member = self.search(uid=user, objects=objects)[0]
        except IndexError:
            return None
        if objects:
            return member
        return member[1]
307560
def list_members(self, list_id):
        
        return [User(user._json) for user in self._client.list_members(list_id=list_id)]
1091788
def get_member_ideas(self, *args, **kwargs):
        
        return bind_api(
            api=self,
            path='/members/{memberId}/ideas',
            payload_type='idea',
            payload_list=True,
            allowed_param=['memberId'],
            pagination_param=['page_number', 'page_size']
        )(*args, **kwargs)
261130
def works(self, member_id):
        
        context = '%s/%s' % (self.ENDPOINT, str(member_id))
        return Works(context=context)
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
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
        )
888721
def list_member_topics(self, member_id):

        ''' 
        '''

    # https://www.meetup.com/meetup_api/docs/members/:member_id/#get

        title = '%s.list_member_topics' % self.__class__.__name__

    # validate inputs
        input_fields = {
            'member_id': member_id
        }
        for key, value in input_fields.items():
            if value:
                object_title = '%s(%s=%s)' % (title, key, str(value))
                self.fields.validate(value, '.%s' % key, object_title)

    # construct member id
        if not member_id:
            raise IndexError('%s requires member id argument.' % title)

    # compose request fields
        url = '%s/members/%s' % (self.endpoint, str(member_id))
        params = {
            'fields': 'topics'
        }

    # send requests
        response_details = self._get_request(url, params=params)

    # construct method output dictionary
        member_topics = {
            'json': []
        }
        for key, value in response_details.items():
            if not key == 'json':
                member_topics[key] = value

    # parse response
        if response_details['json']:
            if 'topics' in response_details['json'].keys():
                for topic in response_details['json']['topics']:
                    member_topics['json'].append(self.objects.topic.ingest(**topic))

        return member_topics
1289702
def getgroupmembers(self, group_id, page=1, per_page=20):
        
        data = {'page': page, 'per_page': per_page}

        request = requests.get(
            '{0}/{1}/members'.format(self.groups_url, group_id), params=data,
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 200:
            return request.json()
        else:
            return False
712530
def get_poolmember_state(self, id_pools, checkstatus=0):
        

        uri = "api/v3/pool/real/%s/member/status/?checkstatus=%s" % (';'.join(id_pools), checkstatus)

        return self.get(uri)
347315
def check_member(m)
      potential_members = self.class::MEMBER_CLASS.map_all_ids_to(:name, api: @api)
      if m.to_s =~ /^\d+$/
        return { id: m.to_i, name: potential_members[m] } if potential_members.key?(m.to_i)
      else
        return { name: m, id: potential_members.invert[m] } if potential_members.value?(m)
      end
      raise JSS::NoSuchItemError, "No #{self.class::MEMBER_CLASS::RSRC_OBJECT_KEY} matching '#{m}' in the JSS."
    end