Fetch and return the comments for a single MoreComments object.
167885
def comments(self, update=True):
        """"""
        if not self._comments:
            if self.count == 0:  # Handle 'continue this thread' type
                return self._continue_comments(update)
            # pylint: disable=W0212
            children = [x for x in self.children if 't1_{0}'.format(x)
                        not in self.submission._comments_by_id]
            # pylint: enable=W0212
            if not children:
                return None
            data = {'children': ','.join(children),
                    'link_id': self.submission.fullname,
                    'r': str(self.submission.subreddit)}

            # pylint: disable=W0212
            if self.submission._comment_sort:
                data['where'] = self.submission._comment_sort
            # pylint: enable=W0212
            url = self.reddit_session.config['morechildren']
            response = self.reddit_session.request_json(url, data=data)
            self._comments = response['data']['things']
            if update:
                for comment in self._comments:
                    # pylint: disable=W0212
                    comment._update_submission(self.submission)
                    # pylint: enable=W0212
        return self._comments
671312
def comments(self, text, start=0):
        

        out = [self.extractChunkContent(s)
               for s in self.chunkComment(text, start)]
        return out
799439
def get_comments(self):
        
        # Lazily load info
        if self.info is None:
            self.get_info()

        if 'comments' in self.info:
            return [structure['text'] for structure in self.info['comments']['comments']]
        else:
            return []
744704
def comments(context, obj):
    
    content_type = ContentType.objects.get_for_model(obj.__class__)
    comment_list = LogEntry.objects.filter(
        content_type=content_type,
        object_id=obj.pk,
        action_flag=COMMENT
    )
    return {
        'obj': obj,
        'comment_list': comment_list,
        'is_admin': context['is_admin'],
    }
722436
def comments(self, limit=None):
        
        return self._reddit.user_comments(self.name, limit=limit)
284983
def get_comments(self):
        """"""
        url = self._imgur._base_url + "/3/gallery/{0}/comments".format(self.id)
        resp = self._imgur._send_request(url)
        return [Comment(com, self._imgur) for com in resp]
216225
def comments(self, limit=None):
        
        return self._reddit.comments(self.display_name, limit=limit)
644679
def comment_count(obj):
    
    model_object = type(obj).objects.get(id=obj.id)
    return model_object.comments.all().count()
1089062
def case_comments(self):
        """"""
        comments = (comment for comment in self.comments if
                    comment.variant_id is None)
        return comments
1175353
def obtain_comments(check = nil)

      if check.blank? && !@content.blank? && @content[0].blank?
        Comment.where(:post_id => @content.id, :comment_approved => 'Y')
      else
        Comment.where(:post_id => check, :comment_approved => 'Y')
      end

    end
777615
def get_votes_comment(self, *args, **kwargs):
        
        return bind_api(
            api=self,
            path='/comments/{commentId}/votes',
            payload_type='vote',
            payload_list=True,
            allowed_param=['commentId']
        )(*args, **kwargs)
606274
def comment_set(self):
        
        ct = ContentType.objects.get_for_model(self.__class__)
        qs = Comment.objects.filter(
            content_type=ct,
            object_pk=self.pk)
        qs = qs.exclude(is_removed=True)
        qs = qs.order_by('-submit_date')
        return qs
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
601026
public String getComment(int index) {
		if (comments == null || index < 0 || index >= comments.size()) {
			throw new IllegalArgumentException("Not a valid comment index: " + index);
		}
		return (String)comments.get(index);
	}
156369
def get_all_comments_of_incoming(self, incoming_id):
        
        return self._iterate_through_pages(
            get_function=self.get_comments_of_incoming_per_page,
            resource=INCOMING_COMMENTS,
            **{'incoming_id': incoming_id}
        )
848553
def get_comments_by_search(self, comment_query, comment_search):
        """"""
        # Implemented from azosid template for -
        # osid.resource.ResourceSearchSession.get_resources_by_search_template
        if not self._can('search'):
            raise PermissionDenied()
        return self._provider_session.get_comments_by_search(comment_query, comment_search)
843554
def itemComments(self):
        
        url = "%s/comments/" % self.root
        params = {
            "f": "json"
        }
        return self._get(url,
                            params,
                            securityHandler=self._securityHandler,
                            proxy_port=self._proxy_port,
                            proxy_url=self._proxy_url)