docs: def find_if_multibase(column, quality_cutoff, base_cutoff, base_fraction_cutoff):
      """
      Finds if a position in a pileup has more than one base present.
      :param column: A pileupColumn generated by pysam
      :param quality_cutoff: Desired minimum phred quality for a base in order to be counted towards a multi-allelic column
      :param base_cutoff: Minimum number of bases needed to support presence of a base.
      :param base_fraction_cutoff: Minimum fraction of bases needed to support presence of a base.
      If specified, noth the base_cutoff and base_fraction_cutoff will have to be met
      :return: If position has more than one base, a dictionary with counts for the bases. Otherwise, returns
      empty dictionary
      """
      # Sometimes the qualities come out to ridiculously high (>70) values. Looks to be because sometimes reads
      # are overlapping and the qualities get summed for overlapping bases. Issue opened on pysam.
      unfiltered_base_qualities = dict()
      for read in column.pileups:
          if read.query_position is not None:  # Not entirely sure why this is sometimes None, but it causes bad stuff
              reference_sequence = read.alignment.get_reference_sequence()
              previous_position = read.query_position - 1 if read.query_position > 1 else 0
              next_position = read.query_position + 1  # This causes index errors. Fix at some point soon.
              # Another stringency check - to make sure that we're actually looking at a point mutation, check that the
              # base before and after the one we're looking at match the reference. With Nanopore data, lots of indels and
              # the like cause false positives, so this filters those out.
              try:  # Need to actually handle this at some point. For now, be lazy
                  previous_reference_base = reference_sequence[previous_position]
                  next_reference_base = reference_sequence[next_position]
                  previous_base = read.alignment.query_sequence[previous_position]
                  next_base = read.alignment.query_sequence[next_position]
                  base = read.alignment.query_sequence[read.query_position]
                  quality = read.alignment.query_qualities[read.query_position]
                  if previous_reference_base == previous_base and next_reference_base == next_base:
                      if base not in unfiltered_base_qualities:
                          unfiltered_base_qualities[base] = [quality]
                      else:
                          unfiltered_base_qualities[base].append(quality)
              except IndexError:
                  pass
  
      # Now check that at least two bases for each of the bases present high quality.
      # first remove all low quality bases
      # Use dictionary comprehension to make a new dictionary where only scores above threshold are kept.
      # Internally list comprehension is used to filter the list
      filtered_base_qualities = {base:[score for score in scores if score >= quality_cutoff] for (base,scores) in unfiltered_base_qualities.items()}
  
      # Now remove bases that have no high quality scores
      # Use dictionary comprehension to make a new dictionary where bases that have a non-empty scores list are kept
      filtered_base_qualities = {base:scores for (base,scores) in filtered_base_qualities.items() if scores}
   
      # If we less than two bases with high quality scores, ignore things.
      if len(filtered_base_qualities) < 2:
          return dict()
  
      # Now that filtered_base_qualities only contains bases with more than one HQ base, make just a dict with base counts with dict comprehension
      high_quality_base_count = {base: len(scores) for (base, scores) in filtered_base_qualities.items()}
      
      if number_of_bases_above_threshold(high_quality_base_count, base_count_cutoff=base_cutoff, base_fraction_cutoff=base_fraction_cutoff) > 1:
          logging.debug('base qualities before filtering: {0}'.format(unfiltered_base_qualities))
          logging.debug('base qualities after filtering: {0}'.format(filtered_base_qualities))
          logging.debug('SNVs found at position {0}: {1}\n'.format(column.pos, high_quality_base_count))
          return high_quality_base_count
      else:
          # logging.debug('No SNVs\n')
          return dict()