docs: def pairwise_align_sequences_to_representative_parallelize(self, sc, gapopen=10, gapextend=0.5, outdir=None,
                                                        engine='needle', parse=True, force_rerun=False):
          """Pairwise all sequences in the sequences attribute to the representative sequence. Stores the alignments
          in the ``sequence_alignments`` DictList attribute.
  
          Args:
              sc (SparkContext): Configured spark context for parallelization
              gapopen (int): Only for ``engine='needle'`` - Gap open penalty is the score taken away when a gap is created
              gapextend (float): Only for ``engine='needle'`` - Gap extension penalty is added to the standard gap penalty
                  for each base or residue in the gap
              outdir (str): Only for ``engine='needle'`` - Path to output directory. Default is the protein sequence
                  directory.
              engine (str): ``biopython`` or ``needle`` - which pairwise alignment program to use.
                  ``needle`` is the standard EMBOSS tool to run pairwise alignments.
                  ``biopython`` is Biopython's implementation of needle. Results can differ!
              parse (bool): Store locations of mutations, insertions, and deletions in the alignment object (as an
                  annotation)
              force_rerun (bool): Only for ``engine='needle'`` - Default False, set to True if you want to rerun the
                  alignment if outfile exists.
  
          """
  
          if not self.representative_sequence:
              raise ValueError('{}: no representative sequence set'.format(self.id))
  
          if not outdir:
              outdir = self.sequence_dir
              if not outdir:
                  raise ValueError('Output directory must be specified')
  
          def pairwise_sc(self, seqprop):
              aln_id = '{}_{}'.format(self.id, seqprop.id)
              outfile = '{}.needle'.format(aln_id)
  
              aln = ssbio.protein.sequence.utils.alignment.pairwise_sequence_alignment(a_seq=self.representative_sequence.seq_str,
                                                                                       a_seq_id=self.id,
                                                                                       b_seq=seqprop.seq_str,
                                                                                       b_seq_id=seqprop.id,
                                                                                       gapopen=gapopen,
                                                                                       gapextend=gapextend,
                                                                                       engine=engine,
                                                                                       outdir=outdir,
                                                                                       outfile=outfile,
                                                                                       force_rerun=force_rerun)
              aln.id = aln_id
              aln.annotations['a_seq'] = self.representative_sequence.id
              aln.annotations['b_seq'] = seqprop.id
  
              if parse:
                  aln_df = ssbio.protein.sequence.utils.alignment.get_alignment_df(a_aln_seq=str(list(aln)[0].seq),
                                                                                   b_aln_seq=str(list(aln)[1].seq))
                  aln.annotations['ssbio_type'] = 'seqalign'
                  aln.annotations['mutations'] = ssbio.protein.sequence.utils.alignment.get_mutations(aln_df)
                  aln.annotations['deletions'] = ssbio.protein.sequence.utils.alignment.get_deletions(aln_df)
                  aln.annotations['insertions'] = ssbio.protein.sequence.utils.alignment.get_insertions(aln_df)
  
              return aln
  
          sequences_rdd = sc.parallelize(filter(lambda x: x.id != self.representative_sequence.id, self.sequences))
          result = sequences_rdd.map(lambda x: pairwise_sc(self, x)).collect()
  
          for r in result:
              self.sequence_alignments.append(r)