:calls: `GET /repos/:owner/:repo/pulls/:number/reviews/:id <https://developer.github.com/v3/pulls/reviews>`_
        :param id: integer
        :rtype: :class:`github.PullRequestReview.PullRequestReview`
975013
def get_review(self, id):
        
        assert isinstance(id, (int, long)), id
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/reviews/" + str(id),
        )
        return github.PullRequestReview.PullRequestReview(self._requester, headers, data, completed=True)
518435
function getPullRequestFiles(resource) {
  return github.pullRequests
    .getFiles({
      owner: resource.owner,
      repo: resource.repo,
      number: resource.number,
      per_page: 100
    })
    .then(function(res) {
      return res.data;
    });
}
589864
def get_pr_review_status(pr: PullRequestDetails) -> Any:
    
    url = ("https://api.github.com/repos/{}/{}/pulls/{}/reviews"
           "?access_token={}".format(pr.repo.organization,
                                     pr.repo.name,
                                     pr.pull_id,
                                     pr.repo.access_token))
    response = requests.get(url)

    if response.status_code != 200:
        raise RuntimeError(
            'Get review failed. Code: {}. Content: {}.'.format(
                response.status_code, response.content))

    return json.JSONDecoder().decode(response.content.decode())
886382
def get_version_by_version_id(version_id):
    
    for ver in registry.version_info:
        if ver.version_id == version_id:
            return ver.id

    return None
158007
def get_issue(self, number):
        
        assert isinstance(number, (int, long)), number
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/issues/" + str(number)
        )
        return github.Issue.Issue(self._requester, headers, data, completed=True)
1276088
def get(user_name, repo_name, reviewer_username, params={})
      update_and_validate_user_repo_params(user_name, repo_name)
      normalize! params

      get_request("/2.0/repositories/#{user_name}/#{repo_name}/default-reviewers/#{reviewer_username}", params)
    end
209021
def satisfaction_rating_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/satisfaction_ratings/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
508230
function _getSHA(id, callback) {
        repo.contents("").fetch({
            ref: options.branch
        }, function(err, res) {
            if (err) return callback(err);
            var sha = res.reduce(function(previousValue, item) {
                return item.name === id ? item.sha : previousValue;
            }, "");
            callback(err, sha);
        });
    }
1140860
def get(self, id):
        
        url = self._url('%s' % (id))
        return self.client.get(url)
992460
def collect_prs_info(self):
        
        REPO_RE = re.compile(
            '^(https://github.com/|git@github.com:)'
            '(?P<owner>.*?)/(?P<repo>.*?)(.git)?$')
        PULL_RE = re.compile(
            '^(refs/)?pull/(?P<pr>[0-9]+)/head$')
        remotes = {r['name']: r['url'] for r in self.remotes}
        all_prs = {}
        for merge in self.merges:
            remote = merge['remote']
            ref = merge['ref']
            repo_url = remotes[remote]
            repo_mo = REPO_RE.match(repo_url)
            if not repo_mo:
                logger.debug('%s is not a github repo', repo_url)
                continue
            pull_mo = PULL_RE.match(ref)
            if not pull_mo:
                logger.debug('%s is not a github pull reqeust', ref)
                continue
            pr_info = {
                'owner': repo_mo.group('owner'),
                'repo': repo_mo.group('repo'),
                'pr': pull_mo.group('pr'),
            }
            pr_info['path'] = '{owner}/{repo}/pulls/{pr}'.format(**pr_info)
            pr_info['url'] = 'https://github.com/{path}'.format(**pr_info)
            pr_info['shortcut'] = '{owner}/{repo}#{pr}'.format(**pr_info)
            r = self._github_api_get('/repos/{path}'.format(**pr_info))
            if r.status_code != 200:
                logger.warning(
                    'Could not get status of {path}. '
                    'Reason: {r.status_code} {r.reason}'.format(r=r, **pr_info)
                )
                continue
            pr_info['state'] = r.json().get('state')
            pr_info['merged'] = (
                not r.json().get('merged') and 'not ' or ''
            ) + 'merged'
            all_prs.setdefault(pr_info['state'], []).append(pr_info)
        return all_prs
1316034
def account(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}'.format(str(id))
        return self.__api_request('GET', url)
688599
def get_pulls_list(project, auth=False, **params):
    """"""
    params.setdefault("state", "closed")
    url = "https://api.github.com/repos/{project}/pulls".format(project=project)
    if auth:
        headers = make_auth_header()
    else:
        headers = None
    pages = get_paged_request(url, headers=headers, **params)
    return pages
610807
def get_pr_checks(pr: PullRequestDetails) -> Dict[str, Any]:
    
    url = ("https://api.github.com/repos/{}/{}/commits/{}/check-runs"
           "?access_token={}".format(pr.repo.organization,
                                     pr.repo.name,
                                     pr.branch_sha,
                                     pr.repo.access_token))
    response = requests.get(
        url,
        headers={'Accept': 'application/vnd.github.antiope-preview+json'})

    if response.status_code != 200:
        raise RuntimeError(
            'Get check-runs failed. Code: {}. Content: {}.'.format(
                response.status_code, response.content))

    return json.JSONDecoder().decode(response.content.decode())
459572
def get_repo_ref(repo: GithubRepository, ref: str) -> Dict[str, Any]:
    

    url = ("https://api.github.com/repos/{}/{}/git/refs/{}"
           "?access_token={}".format(repo.organization,
                                     repo.name,
                                     ref,
                                     repo.access_token))
    response = requests.get(url)
    if response.status_code != 200:
        raise RuntimeError(
            'Refs get failed. Code: {}. Content: {}.'.format(
                response.status_code, response.content))
    payload = json.JSONDecoder().decode(response.content.decode())
    return payload
512710
def repo_model(self):
        """"""
        return Repository.query.filter_by(
            user_id=self.event.user_id,
            github_id=self.repository['id'],
        ).one()
1079387
def review(id)
      data = request("/review/show", id: id)
      Hashie::Mash.new(data["review"])
    end
774972
def get_by_id_or_404(self, id, **kwargs):
        """"""
        obj = self.get_by_id(id=id, **kwargs)

        if obj:
            return obj

        raise Http404