:calls: `GET /teams/:id/members/:user <http://developer.github.com/v3/orgs/teams>`_
        :param member: :class:`github.NamedUser.NamedUser`
        :rtype: bool
4497
def has_in_members(self, member):
        
        assert isinstance(member, github.NamedUser.NamedUser), member
        status, headers, data = self._requester.requestJson(
            "GET",
            self.url + "/members/" + member._identity
        )
        return status == 204
1207198
def _member_def(self, member):
        
        member_docstring = textwrap.dedent(member.docstring).strip()
        member_docstring = textwrap.fill(
            member_docstring, width=78, initial_indent=' '*4,
            subsequent_indent=' '*4
        )
        return '%s\n%s\n' % (member.name, member_docstring)
593952
def member(id, request = true)
      id = id.resolve_id
      return @members[id] if member_cached?(id)
      return nil unless request

      member = @bot.member(self, id)
      @members[id] = member unless member.nil?
    rescue StandardError
      nil
    end
299299
def find_by_id(self, project_membership, params={}, **options): 
        
        path = "/project_memberships/%s" % (project_membership)
        return self.client.get(path, params, **options)
332445
def get_user(self, user):
        
        self.project_service.set_auth(self._token_project)
        return self.project_service.get_user(user)
554156
def get_assignee(self, login):
        
        if not login:
            return GithubObject.NotSet
        if not hasattr(self, '_assignees'):
            self._assignees = {c.login: c for c in self.repo.get_assignees()}
        if login not in self._assignees:
            # warning
            print("{} doesn't belong to this repo. This issue won't be assigned.".format(login))
        return self._assignees.get(login)
1294259
def team_profile_get(self, **kwargs) -> SlackResponse:
        """"""
        self._validate_xoxp_token()
        return self.api_call("team.profile.get", http_verb="GET", params=kwargs)
664930
def get_user(self, username):
        
        for user in self.users:
            if user.id.name == username:
                return user
        return None
112434
def add_member_team(self, team, permissions):
        
        team = Transform.to_team(team)
        data = {'id': team, 'type': 'TEAM'}
        if isinstance(permissions, dict):
            data.update({
                'permissions': permissions
            })

        extra = {
            'resource': self.__class__.__name__,
            'query': {
                'id': self.id,
                'data': data,
            }
        }
        logger.info('Adding team member using team id', extra=extra)
        response = self._api.post(
            url=self._URL['members_query'].format(id=self.id), data=data)
        member_data = response.json()
        return Member(api=self._api, **member_data)
230117
def getmember(self, name):
        '''
        
        '''
        members = self.getmembers()
        for m in members[::-1]:
            if m.name == name:
                return m

        raise KeyError("member %s could not be found" % name)
941051
def get_user(user_or_username):
    
    user = None
    if isinstance(user_or_username, MemberData):
        user = user_or_username
    if isinstance(user_or_username, basestring):
        user = get_member_by_login_name(get_portal(), user_or_username, False)
    return user
672773
def get_member(self, name):
        """"""
        for member in self.members:
            if member.name == name:
                return member

        return None
964192
def team(self, team_id):
        
        json = None
        if int(team_id) > 0:
            url = self._build_url('teams', str(team_id))
            json = self._json(self._get(url), 200)
        return Team(json, self._session) if json else None
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]
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
        )
335467
def get_user(self, user_id):
        
        url = self.TEAM_USERS_ID_URL % user_id

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

        return connection.get_request()
940338
def hasUser(self):
        
        username = self.getUsername()
        if not username:
            return False
        user = api.get_user(username)
        return user is not None