:calls: `GET /repos/:owner/:repo/issues/:number/comments <http://developer.github.com/v3/issues/comments>`_
        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.IssueComment.IssueComment`
433030
def get_issue_comments(self):
        
        return github.PaginatedList.PaginatedList(
            github.IssueComment.IssueComment,
            self._requester,
            self.issue_url + "/comments",
            None
        )
1181508
public List<Comment> getComments(String commentsUrl, GitHubRepo repo) throws RestClientException {

        List<Comment> comments = new ArrayList<>();

        // decrypt password
        String decryptedPassword = decryptString(repo.getPassword(), settings.getKey());

        String personalAccessToken = (String) repo.getOptions().get("personalAccessToken");
        String decryptedPersonalAccessToken = decryptString(personalAccessToken, settings.getKey());

        boolean lastPage = false;
        String queryUrlPage = commentsUrl;
        while (!lastPage) {
            ResponseEntity<String> response = makeRestCall(queryUrlPage, repo.getUserId(), decryptedPassword,decryptedPersonalAccessToken);
            JSONArray jsonArray = parseAsArray(response);
            for (Object item : jsonArray) {
                JSONObject jsonObject = (JSONObject) item;

                Comment comment = new Comment();
                JSONObject userJsonObj = (JSONObject) jsonObject.get("user");
                comment.setUser((String) userJsonObj.get("login"));
                long crt = new DateTime(str(jsonObject, "created_at")).getMillis();
                comment.setCreatedAt(crt);
                long upd = new DateTime(str(jsonObject, "updated_at")).getMillis();
                comment.setUpdatedAt(upd);
                comment.setBody(str(jsonObject, "body"));
                comments.add(comment);
            }
            if (CollectionUtils.isEmpty(jsonArray)) {
                lastPage = true;
            } else {
                if (isThisLastPage(response)) {
                    lastPage = true;
                } else {
                    lastPage = false;
                    queryUrlPage = getNextPageUrl(response);
                }
            }
        }
        return comments;
    }
752663
def comment(self, body):
        
        self.github_request.comment(issue=self, body=body)

        if self.state == 'closed':
            self.open_issue()
        return self
1163491
def comments(self, issue):
        
        commit = self.as_id(issue)
        return self.get_list(url='%s/%s/comments' % (self, commit))
1095846
public function createComment($owner, $repo, $issue, $body)
	{
		$data = array();
		$data['body'] = $body;
		
		return $this->client->request("/repos/$owner/$repo/issues/$issue/comments", 'POST', json_encode($data), 201, 'GitHubIssueComment');
	}
979829
public function listComments(): array
    {
        return $this->getApi()->request($this->getApi()->sprintf('/repos/:owner/:repo/comments',
            $this->getRepositories()->getOwner(), $this->getRepositories()->getRepo()));
    }
1287600
def comments(object):
    
    return Comment.objects.filter(
        object_id=object.pk,
        content_type=ContentType.objects.get_for_model(object)
    )
1112796
def get_comments(obj, request, oauth=False, paginate=False, cpp=10):
    
    model_object = type(obj).objects.get(id=obj.id)
    comments = Comment.objects.filter_by_object(model_object)
    comments_count = comments.count()
    if paginate:
        paginator = Paginator(comments, cpp)
        page = request.GET.get('page')
        try:
            comments = paginator.page(page)
        except PageNotAnInteger:
            comments = paginator.page(1)
        except EmptyPage:
            comments = paginator.page(paginator.num_pages)

    try:
        profile_app_name = settings.PROFILE_APP_NAME
        profile_model_name = settings.PROFILE_MODEL_NAME
    except AttributeError:
        profile_app_name = None
        profile_model_name = None

    try:
        if settings.LOGIN_URL.startswith("/"):
            login_url = settings.LOGIN_URL
        else:
            login_url = "/" + settings.LOGIN_URL
    except AttributeError:
        login_url = ""

    return {
        "commentform": CommentForm(),
        "model_object": obj,
        "user": request.user,
        "comments": comments,
        # "comments_count": comments_count,
        "oauth": oauth,
        "profile_app_name": profile_app_name,
        "profile_model_name": profile_model_name,
        "paginate": paginate,
        "login_url": login_url,
        "cpp": cpp
    }
28097
def get_statuses(self):
        
        return github.PaginatedList.PaginatedList(
            github.CommitStatus.CommitStatus,
            self._requester,
            self._parentUrl(self._parentUrl(self.url)) + "/statuses/" + self.sha,
            None
        )
960257
def create_comment(self, body):
        
        assert isinstance(body, (str, unicode)), body
        post_parameters = {
            "body": body,
        }
        headers, data = self._requester.requestJsonAndCheck(
            "POST",
            self.url + "/comments",
            input=post_parameters
        )
        return github.IssueComment.IssueComment(self._requester, headers, data, completed=True)
904784
def fetch_comments_async(prs)
      threads = []

      prs.each_slice(MAX_THREAD_NUMBER) do |prs_slice|
        prs_slice.each do |pr|
          threads << Thread.new do
            pr["comments"] = []
            iterate_pages(@client, "issue_comments", pr["number"]) do |new_comment|
              pr["comments"].concat(new_comment)
            end
            pr["comments"] = pr["comments"].map { |comment| stringify_keys_deep(comment.to_hash) }
          end
        end
        threads.each(&:join)
        threads = []
      end
      nil
    end
519461
def get_list_comment(self, issue_id, comment_id):
        
        request_url = "{}issue/{}/comment/{}".format(self.create_basic_url(),
                                                     issue_id, comment_id)

        return_value = self._call_api(request_url)

        return return_value
1272448
def _get_comments(session, group_or_user_id, wall_id):
        
        return session.fetch_items("wall.getComments", Comment.from_json, count=100, owner_id=group_or_user_id, post_id=wall_id, need_likes=1)
305080
function attachCommentReply(comment) {
    return function reply(body, callback) {
        github.replyToReviewComment(this.repo.data.owner.login, this.repo.data.name, this.data.number, comment.id, body, callback);
    }.bind(this);
}
11722
public function listRepositoryComments(string $sort = AbstractApi::SORT_CREATED,
                                           string $direction = AbstractApi::DIRECTION_DESC,
                                           string $since = 'now'): array
    {
        return $this->getApi()->request($this->getApi()->sprintf('/repos/:owner/:repo/issues/comments?:args',
            $this->getIssues()->getOwner(), $this->getIssues()->getRepo(), http_build_query([
                'sort'      => $sort,
                'direction' => $direction,
                'since'     => $since
            ])));
    }
456002
public function listStatusesForSpecificRef($owner, $repo, $ref)
	{
		$data = array();
		$data['ref'] = $ref;
		
		return $this->client->request("/repos/$owner/$repo/commits/$ref/statuses", 'GET', $data, 200, 'GitHubStatus', true);
	}
384804
def get_comments(self, commentable_type, id_):
    
    return _get_request(_COM.format(c_api=_C_API_BEGINNING,
                                            ct=commentable_type,
                                            id_=id_,
                                            api=_API_VERSION,
                                            at=self.access_token))