docs: def local_alignment(query, target=None, targets=None, match=3, mismatch=-2,
          gap_open=-5, gap_extend=-2, matrix=None, aa=False, gap_open_penalty=None, gap_extend_penalty=None):
      '''
      Striped Smith-Waterman local pairwise alignment.
  
      Args:
  
          query: Query sequence. ``query`` can be one of four things:
  
              1. a nucleotide or amino acid sequence, as a string
  
              2. a Biopython ``SeqRecord`` object
  
              3. an AbTools ``Sequence`` object
  
              4. a list/tuple of the format ``[seq_id, sequence]``
  
          target: A single target sequence. ``target`` can be anything that
              ``query`` accepts.
  
          targets (list): A list of target sequences, to be proccssed iteratively.
              Each element in the ``targets`` list can be anything accepted by
              ``query``.
  
          match (int): Match score. Should be a positive integer. Default is 3.
  
          mismatch (int): Mismatch score. Should be a negative integer. Default is -2.
  
          gap_open (int): Penalty for opening gaps. Should be a negative integer.
              Default is -5.
  
          gap_extend (int): Penalty for extending gaps. Should be a negative
              integer. Default is -2.
  
          matrix (str, dict): Alignment scoring matrix. Two options for passing the
              alignment matrix:
  
              - The name of a built-in matrix. Current options are ``blosum62`` and ``pam250``.
  
              - A nested dictionary, giving an alignment score for each residue pair. Should be formatted
                such that retrieving the alignment score for A and G is accomplished by::
  
                  matrix['A']['G']
  
          aa (bool): Must be set to ``True`` if aligning amino acid sequences. Default
              is ``False``.
  
      Returns:
  
          If a single target sequence is provided (via ``target``), a single ``SSWAlignment``
          object will be returned. If multiple target sequences are supplied (via ``targets``),
          a list of ``SSWAlignment`` objects will be returned.
      '''
      if aa and not matrix:
          err = 'ERROR: You must supply a scoring matrix for amino acid alignments'
          raise RuntimeError(err)
      if not target and not targets:
          err = 'ERROR: You must supply a target sequence (or sequences).'
          raise RuntimeError(err)
      if target:
          targets = [target, ]
      # to maintain backward compatibility with earlier AbTools API
      if gap_open_penalty is not None:
          gap_open = -1 * gap_open_penalty
      if gap_extend_penalty is not None:
          gap_extend = -1 * gap_extend_penalty
      alignments = []
      for t in targets:
          try:
              alignment = SSWAlignment(query=query,
                                       target=t,
                                       match=match,
                                       mismatch=mismatch,
                                       matrix=matrix,
                                       gap_open=-1 * gap_open,
                                       gap_extend=-1 * gap_extend,
                                       aa=aa)
              alignments.append(alignment)
          except IndexError:
              continue
      if len(alignments) == 1:
          return alignments[0]
      return alignments