docs: def get_top_submissions(course_id, item_id, item_type, number_of_top_scores, use_cache=True, read_replica=True):
      """Get a number of top scores for an assessment based on a particular student item
  
      This function will return top scores for the piece of assessment.
      It will consider only the latest and greater than 0 score for a piece of assessment.
      A score is only calculated for a student item if it has completed the workflow for
      a particular assessment module.
  
      In general, users of top submissions can tolerate some latency
      in the search results, so by default this call uses
      a cache and the read replica (if available).
  
      Args:
          course_id (str): The course to retrieve for the top scores
          item_id (str): The item within the course to retrieve for the top scores
          item_type (str): The type of item to retrieve
          number_of_top_scores (int): The number of scores to return, greater than 0 and no
          more than 100.
  
      Kwargs:
          use_cache (bool): If true, check the cache before retrieving querying the database.
          read_replica (bool): If true, attempt to use the read replica database.
              If no read replica is available, use the default database.
  
      Returns:
          topscores (dict): The top scores for the assessment for the student item.
              An empty array if there are no scores or all scores are 0.
  
      Raises:
          SubmissionNotFoundError: Raised when a submission cannot be found for
              the associated student item.
          SubmissionRequestError: Raised when the number of top scores is higher than the
              MAX_TOP_SUBMISSIONS constant.
  
      Examples:
          >>> course_id = "TestCourse"
          >>> item_id = "u_67"
          >>> item_type = "openassessment"
          >>> number_of_top_scores = 10
          >>>
          >>> get_top_submissions(course_id, item_id, item_type, number_of_top_scores)
          [{
              'score': 20,
              'content': "Platypus"
          },{
              'score': 16,
              'content': "Frog"
          }]
  
      """
      if number_of_top_scores < 1 or number_of_top_scores > MAX_TOP_SUBMISSIONS:
          error_msg = (
              u"Number of top scores must be a number between 1 and {}.".format(MAX_TOP_SUBMISSIONS)
          )
          logger.exception(error_msg)
          raise SubmissionRequestError(msg=error_msg)
  
      # First check the cache (unless caching is disabled)
      cache_key = "submissions.top_submissions.{course}.{item}.{type}.{number}".format(
          course=course_id,
          item=item_id,
          type=item_type,
          number=number_of_top_scores
      )
      top_submissions = cache.get(cache_key) if use_cache else None
  
      # If we can't find it in the cache (or caching is disabled), check the database
      # By default, prefer the read-replica.
      if top_submissions is None:
          try:
              query = ScoreSummary.objects.filter(
                  student_item__course_id=course_id,
                  student_item__item_id=item_id,
                  student_item__item_type=item_type,
                  latest__points_earned__gt=0
              ).select_related('latest', 'latest__submission').order_by("-latest__points_earned")
  
              if read_replica:
                  query = _use_read_replica(query)
              score_summaries = query[:number_of_top_scores]
          except DatabaseError:
              msg = u"Could not fetch top score summaries for course {}, item {} of type {}".format(
                  course_id, item_id, item_type
              )
              logger.exception(msg)
              raise SubmissionInternalError(msg)
  
          # Retrieve the submission content for each top score
          top_submissions = [
              {
                  "score": score_summary.latest.points_earned,
                  "content": SubmissionSerializer(score_summary.latest.submission).data['answer']
              }
              for score_summary in score_summaries
          ]
  
          # Always store the retrieved list in the cache
          cache.set(cache_key, top_submissions, TOP_SUBMISSIONS_CACHE_TIMEOUT)
  
      return top_submissions