docs: def alignment_correcter(self, alignment_file_list, output_file_name,
                              filter_minimum=None):
          '''
          Remove lower case insertions in alignment outputs from HMM align. Give
          a list of alignments, and an output file name, and each alignment will
          be corrected, and written to a single file, ready to be placed together
          using pplacer.
  
          Parameters
          ----------
          alignment_file_list : array
              List of strings, each the path to different alignments from the
              inputs provided to GraftM
          output_file_name : str
              The path and filename of the output file desired.
          filter_minimum : int
              minimum number of positions that must be aligned for each sequence
          Returns
          -------
          True or False, depending if reads were written to file
  
          '''
  
          corrected_sequences = {}
          for alignment_file in alignment_file_list:
              insert_list = []  # Define list containing inserted positions to be removed (lower case characters)
              sequence_list = list(SeqIO.parse(open(alignment_file, 'r'), 'fasta'))
              for sequence in sequence_list:  # For each sequence in the alignment
                  for idx, nt in enumerate(list(sequence.seq)):  # For each nucleotide in the sequence
                      if nt.islower():  # Check for lower case character
                          insert_list.append(idx)  # Add to the insert list if it is
              insert_list = list(OrderedDict.fromkeys(sorted(insert_list, reverse=True)))  # Reverse the list and remove duplicate positions
              for sequence in sequence_list:  # For each sequence in the alignment
                  new_seq = list(sequence.seq)  # Define a list of sequences to be iterable list for writing
                  for position in insert_list:  # For each position in the removal list
                      del new_seq[position]  # Delete that inserted position in every sequence
                  corrected_sequences['>' + sequence.id + '\n'] = (''.join(new_seq) + '\n').replace('~', '-')
          
          pre_filter_count=len(corrected_sequences)
          
          if filter_minimum:
              # Use '>' not '>=' here because the sequence is on a single line, 
              # but also includes a newline character at the end of the sequence
              corrected_sequences={key:item for key, item in corrected_sequences.iteritems() if len(item.replace('-', '')) > filter_minimum}
          
          post_filter_count=len(corrected_sequences)
          logging.info("Filtered %i short sequences from the alignment" % \
                          (pre_filter_count-post_filter_count)
                      )
          logging.info("%i sequences remaining" % post_filter_count)
          
          if len(corrected_sequences) >= 1:
              with open(output_file_name, 'w') as output_file:  # Create an open file to write the new sequences to
                  for fasta_id, fasta_seq in corrected_sequences.iteritems():
                      output_file.write(fasta_id)
                      output_file.write(fasta_seq)
              return True
          else:
              return False