docs: def add_mutations_to_nglview(self, view, alignment_type='seqalign', alignment_ids=None,
                                   seqprop=None, structprop=None, chain_id=None, use_representatives=False,
                                   grouped=False, color='red', unique_colors=True,
                                   opacity_range=(0.8,1), scale_range=(1,5)):
          """Add representations to an NGLWidget view object for residues that are mutated in the
          ``sequence_alignments`` attribute.
  
          Args:
              view (NGLWidget): NGLWidget view object
              alignment_type (str): Specified alignment type contained in the ``annotation`` field of an alignment object,
                  ``seqalign`` or ``structalign`` are the current types.
              alignment_ids (str, list): Specified alignment ID or IDs to use
              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
              grouped (bool): If groups of mutations should be colored and sized together
              color (str): Color of the mutations (overridden if unique_colors=True)
              unique_colors (bool): If each mutation/mutation group should be colored uniquely
              opacity_range (tuple): Min/max opacity values (mutations that show up more will be opaque)
              scale_range (tuple): Min/max size values (mutations that show up more will be bigger)
  
          """
          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))
  
          # Get the summary of mutations
          single, fingerprint = self.sequence_mutation_summary(alignment_type=alignment_type, alignment_ids=alignment_ids)
  
          # Map residues from sequence to structure
          if not grouped:
              single_lens = {k: len(v) for k, v in single.items()}
              single_map_to_structure = {}
  
              for k, v in single_lens.items():
                  resnum = int(k[1])
                  resnum_to_structure = self.map_seqprop_resnums_to_structprop_resnums(resnums=resnum,
                                                                                       seqprop=seqprop,
                                                                                       structprop=structprop,
                                                                                       chain_id=chain_id,
                                                                                       use_representatives=use_representatives)
                  if resnum not in resnum_to_structure:
                      log.warning('{}: residue is not available in structure {}'.format(resnum, structprop.id))
                      continue
                  new_key = resnum_to_structure[resnum]
                  single_map_to_structure[new_key] = v
  
              structprop.add_scaled_residues_highlight_to_nglview(view=view,
                                                                  structure_resnums=single_map_to_structure,
                                                                  chain=chain_id,
                                                                  color=color,
                                                                  unique_colors=unique_colors,
                                                                  opacity_range=opacity_range,
                                                                  scale_range=scale_range)
          else:
              log.warning('Viewing mutation groups is currently in beta -- groups may overwrite each other')
              fingerprint_lens = {k: len(v) for k, v in fingerprint.items()}
              fingerprint_map_to_structure = {}
  
              for k, v in fingerprint_lens.items():
                  k_list = [int(x[1]) for x in k]
                  resnums_to_structure = self.map_seqprop_resnums_to_structprop_resnums(resnums=k_list,
                                                                                        seqprop=seqprop,
                                                                                        structprop=structprop,
                                                                                        chain_id=chain_id,
                                                                                        use_representatives=use_representatives)
                  new_key = tuple(y for y in resnums_to_structure.values())
                  fingerprint_map_to_structure[new_key] = v
  
              structprop.add_scaled_residues_highlight_to_nglview(view=view,
                                                                  structure_resnums=fingerprint_map_to_structure,
                                                                  chain=chain_id,
                                                                  color=color,
                                                                  unique_colors=unique_colors,
                                                                  opacity_range=opacity_range,
                                                                  scale_range=scale_range)