docs: def load_kegg(self, kegg_id, kegg_organism_code=None, kegg_seq_file=None, kegg_metadata_file=None,
                    set_as_representative=False, download=False, outdir=None, force_rerun=False):
          """Load a KEGG ID, sequence, and metadata files into the sequences attribute.
  
          Args:
              kegg_id (str): KEGG ID
              kegg_organism_code (str): KEGG organism code to prepend to the kegg_id if not part of it already.
                  Example: ``eco:b1244``, ``eco`` is the organism code
              kegg_seq_file (str): Path to KEGG FASTA file
              kegg_metadata_file (str): Path to KEGG metadata file (raw KEGG format)
              set_as_representative (bool): If this KEGG ID should be set as the representative sequence
              download (bool): If the KEGG sequence and metadata files should be downloaded if not provided
              outdir (str): Where the sequence and metadata files should be downloaded to
              force_rerun (bool): If ID should be reloaded and files redownloaded
  
          Returns:
              KEGGProp: object contained in the sequences attribute
  
          """
          if download:
              if not outdir:
                  outdir = self.sequence_dir
                  if not outdir:
                      raise ValueError('Output directory must be specified')
  
          if kegg_organism_code:
              kegg_id = kegg_organism_code + ':' + kegg_id
  
          # If we have already loaded the KEGG ID
          if self.sequences.has_id(kegg_id):
              # Remove it if we want to force rerun things
              if force_rerun:
                  existing = self.sequences.get_by_id(kegg_id)
                  self.sequences.remove(existing)
              # Otherwise just get that KEGG object
              else:
                  log.debug('{}: KEGG ID already present in list of sequences'.format(kegg_id))
                  kegg_prop = self.sequences.get_by_id(kegg_id)
  
          # Check again (instead of else) in case we removed it if force rerun
          if not self.sequences.has_id(kegg_id):
              kegg_prop = KEGGProp(id=kegg_id, seq=None, fasta_path=kegg_seq_file, txt_path=kegg_metadata_file)
              if download:
                  kegg_prop.download_seq_file(outdir, force_rerun)
                  kegg_prop.download_metadata_file(outdir, force_rerun)
  
              # Check if KEGG sequence matches a potentially set representative sequence
              # Do not add any info if a UniProt ID was already mapped though, we want to use that
              if self.representative_sequence:
                  if not self.representative_sequence.uniprot:
                      if kegg_prop.equal_to(self.representative_sequence):
                          # Update the representative sequence field with KEGG metadata
                          self.representative_sequence.update(kegg_prop.get_dict(), only_keys=['sequence_path',
                                                                                               'metadata_path',
                                                                                               'kegg',
                                                                                               'description',
                                                                                               'taxonomy',
                                                                                               'id',
                                                                                               'pdbs',
                                                                                               'uniprot',
                                                                                               'seq_record',
                                                                                               'gene_name',
                                                                                               'refseq'])
                      else:
                          # TODO: add option to use manual or kegg sequence if things do not match
                          log.warning('{}: representative sequence does not match mapped KEGG sequence.'.format(self.id))
  
              self.sequences.append(kegg_prop)
  
          if set_as_representative:
              self.representative_sequence = kegg_prop
  
          return self.sequences.get_by_id(kegg_id)