docs: def get_residue_annotations(self, seq_resnum, seqprop=None, structprop=None, chain_id=None,
                                  use_representatives=False):
          """Get all residue-level annotations stored in the SeqProp ``letter_annotations`` field for a given residue number.
  
          Uses the representative sequence, structure, and chain ID stored by default. If other properties from other
          structures are desired, input the proper IDs. An alignment for the given sequence to the structure must
          be present in the sequence_alignments list.
  
          Args:
              seq_resnum (int): Residue number in the sequence
              seqprop (SeqProp): SeqProp object
              structprop (StructProp): StructProp object
              chain_id (str): ID of the structure's chain to get annotation from
              use_representatives (bool): If the representative sequence/structure/chain IDs should be used
  
          Returns:
              dict: All available letter_annotations for this residue number
  
          """
  
          if use_representatives:
              if seqprop and structprop and chain_id:
                  raise ValueError('Overriding sequence, structure, and chain IDs with representatives. '
                                   'Set use_representatives to False if custom IDs are to be used.')
          else:
              if not seqprop or not structprop or not chain_id:
                  raise ValueError('Input sequence, structure, and chain to map between, or set use_representatives '
                                   'to True.')
  
          if use_representatives:
              seqprop = self.representative_sequence
              structprop = self.representative_structure
              chain_id = self.representative_chain
  
          # log.debug('Using sequence: {}, structure: {}, chain: {}'.format(seqprop.id, structprop.id, chain_id))
  
          # Create a new SeqFeature
          f = SeqFeature(FeatureLocation(seq_resnum-1, seq_resnum))
  
          # Get sequence properties
          seq_features = f.extract(seqprop)
  
          # Store in dictionary to return, clean it up
          all_info = ssbio.utils.clean_single_dict(indict=seq_features.letter_annotations,
                                                   prepend_to_keys='seq_',
                                                   remove_keys_containing='_chain_index')
          all_info['seq_resnum'] = seq_resnum
          all_info['seq_residue'] = str(seq_features.seq)
  
          if structprop:
              chain = structprop.chains.get_by_id(chain_id)
  
              # Get structure properties
              mapping_to_structure_resnum = self.map_seqprop_resnums_to_structprop_resnums(resnums=seq_resnum,
                                                                                           seqprop=seqprop,
                                                                                           structprop=structprop,
                                                                                           chain_id=chain_id,
                                                                                           use_representatives=use_representatives)
  
              # Try finding the residue in the structure
              if f.location.end.position in mapping_to_structure_resnum:
                  struct_resnum = mapping_to_structure_resnum[f.location.end.position]
                  struct_f = SeqFeature(FeatureLocation(struct_resnum-1, struct_resnum))
  
                  struct_seq_features = struct_f.extract(chain.seq_record)
                  struct_info = ssbio.utils.clean_single_dict(indict=struct_seq_features.letter_annotations,
                                                              prepend_to_keys='struct_',
                                                              remove_keys_containing='structure_resnums')
                  struct_info['struct_resnum'] = struct_resnum
                  struct_info['struct_residue'] = str(struct_seq_features.seq)
                  all_info.update(struct_info)
  
                  # Warn if residue differs from sequence
                  if seq_features.seq != struct_seq_features.seq:
                      log.warning('Sequence residue ({}{}) does not match structure residue ({}{}). '
                                  'This may simply be due to differences in the structure'.format(seq_features.seq,
                                                                                                  seq_resnum,
                                                                                                  struct_seq_features.seq,
                                                                                                  struct_resnum))
  
          return all_info