docs: def set_representative_sequence(self, force_rerun=False):
          """Automatically consolidate loaded sequences (manual, UniProt, or KEGG) and set a single representative
          sequence.
  
          Manually set representative sequences override all existing mappings. UniProt mappings override KEGG mappings
          except when KEGG mappings have PDBs associated with them and UniProt doesn't.
  
          Args:
              force_rerun (bool): Set to True to recheck stored sequences
  
          Returns:
              SeqProp: Which sequence was set as representative
  
          """
  
          if len(self.sequences) == 0:
              log.error('{}: no sequences mapped'.format(self.id))
              return self.representative_sequence
  
          kegg_mappings = self.filter_sequences(KEGGProp)
          if len(kegg_mappings) > 0:
              kegg_to_use = kegg_mappings[0]
              if len(kegg_mappings) > 1:
                  log.warning('{}: multiple KEGG mappings found, using the first entry {}'.format(self.id, kegg_to_use.id))
  
          uniprot_mappings = self.filter_sequences(UniProtProp)
  
          # If a representative sequence has already been set, nothing needs to be done
          if self.representative_sequence and not force_rerun:
              log.debug('{}: representative sequence already set'.format(self.id))
  
          # If there is a KEGG annotation and no UniProt annotations, set KEGG as representative
          elif len(kegg_mappings) > 0 and len(uniprot_mappings) == 0:
              self.representative_sequence = kegg_to_use
              log.debug('{}: representative sequence set from KEGG ID {}'.format(self.id, kegg_to_use.id))
  
          # If there are UniProt annotations and no KEGG annotations, set UniProt as representative
          elif len(kegg_mappings) == 0 and len(uniprot_mappings) > 0:
              # If there are multiple uniprots rank them by the sum of reviewed (bool) + num_pdbs
              # This way, UniProts with PDBs get ranked to the top, or if no PDBs, reviewed entries
              u_ranker = []
              for u in uniprot_mappings:
                  u_ranker.append((u.id, u.ranking_score()))
              sorted_by_second = sorted(u_ranker, key=lambda tup: tup[1], reverse=True)
              best_u_id = sorted_by_second[0][0]
  
              best_u = uniprot_mappings.get_by_id(best_u_id)
              self.representative_sequence = best_u
              log.debug('{}: representative sequence set from UniProt ID {}'.format(self.id, best_u_id))
  
          # If there are both UniProt and KEGG annotations...
          elif len(kegg_mappings) > 0 and len(uniprot_mappings) > 0:
              # Use KEGG if the mapped UniProt is unique, and it has PDBs
              if kegg_to_use.num_pdbs > 0 and not uniprot_mappings.has_id(kegg_to_use.uniprot):
                  self.representative_sequence = kegg_to_use
                  log.debug('{}: representative sequence set from KEGG ID {}'.format(self.id, kegg_to_use.id))
              else:
                  # If there are multiple uniprots rank them by the sum of reviewed (bool) + num_pdbs
                  u_ranker = []
                  for u in uniprot_mappings:
                      u_ranker.append((u.id, u.ranking_score()))
                  sorted_by_second = sorted(u_ranker, key=lambda tup: tup[1], reverse=True)
                  best_u_id = sorted_by_second[0][0]
  
                  best_u = uniprot_mappings.get_by_id(best_u_id)
                  self.representative_sequence = best_u
                  log.debug('{}: representative sequence set from UniProt ID {}'.format(self.id, best_u_id))
  
          return self.representative_sequence