code: def probable_languages(
              self,
              text: str,
              max_languages: int = 3) -> Tuple[str, ...]:
          
          scores = self.scores(text)
  
          # Sorted from the most probable language to the least probable
          sorted_scores = sorted(scores.items(), key=itemgetter(1), reverse=True)
          languages, probabilities = list(zip(*sorted_scores))
  
          # Find the most distant consecutive languages.
          # A logarithmic scale is used here because the probabilities
          # are most of the time really close to zero
          rescaled_probabilities = [log(proba) for proba in probabilities]
          distances = [
              rescaled_probabilities[pos] - rescaled_probabilities[pos+1]
              for pos in range(len(rescaled_probabilities)-1)]
  
          max_distance_pos = max(enumerate(distances, 1), key=itemgetter(1))[0]
          limit = min(max_distance_pos, max_languages)
          return languages[:limit]
docs: List of most probable programming languages,
          the list is ordered from the most probable to the least probable one.
  
          :param text: source code.
          :param max_languages: maximum number of listed languages.
          :return: languages list