docs: def _get_alignment_lines(self):
          ''' This function parses the Clustal Omega alignment output and returns the aligned sequences in a dict: sequence_id -> sequence_string.
              The special key -1 is reserved for the match line (e.g. ' .:******* *').'''
  
          # Strip the boilerplate lines
          lines = self.alignment_output.split("\n")
          assert(lines[0].startswith('CLUSTAL'))
          lines = '\n'.join(lines[1:]).lstrip().split('\n')
  
          # The sequence IDs should be unique. Reassert this here
          assert(len(self.sequence_ids.values()) == len(set(self.sequence_ids.values())))
  
          # Create the list of sequence IDs
          id_list = [v for k, v in sorted(self.sequence_ids.iteritems())]
  
          # Determine the indentation level
          first_id = id_list[0]
          header_regex = re.compile("(.*?\s+)(.*)")
          alignment_regex = re.compile("^([A-Z\-]+)\s*$")
          mtchs = header_regex.match(lines[0])
          assert(mtchs.group(1).strip() == first_id)
          indentation = len(mtchs.group(1))
          sequence = mtchs.group(2)
          assert(sequence)
          assert(alignment_regex.match(sequence))
  
          # Create empty lists for the sequences
          sequences = {}
          for id in id_list:
              sequences[id] = []
          sequences[-1] = []
  
          # Get the lists of sequences
          num_ids = len(id_list)
          for x in range(0, len(lines), num_ids + 2):
              for y in range(num_ids):
                  id = id_list[y]
                  assert(lines[x + y][:indentation].strip() == id)
                  assert(lines[x + y][indentation - 1] == ' ')
                  sequence = lines[x + y][indentation:].strip()
                  assert(alignment_regex.match(sequence))
                  sequences[id].append(sequence)
  
              # Get the length of the sequence lines
              length_of_sequences = list(set(map(len, [v[-1] for k, v in sequences.iteritems() if k != -1])))
              assert(len(length_of_sequences) == 1)
              length_of_sequences = length_of_sequences[0]
  
              # Parse the Clustal match line
              assert(lines[x + num_ids][:indentation].strip() == '')
              match_sequence = lines[x + num_ids][indentation:indentation + length_of_sequences]
              assert(match_sequence.strip() == lines[x + num_ids].strip())
              assert(lines[x + y][indentation - 1] == ' ')
              sequences[-1].append(match_sequence)
  
              # Check for the empty line
              assert(lines[x + num_ids + 1].strip() == '')
  
          # Create the sequences, making sure that all sequences are the same length
          lengths = set()
          for k, v in sequences.iteritems():
              sequences[k] = "".join(v)
              lengths.add(len(sequences[k]))
          assert(len(lengths) == 1)
  
          return sequences