# Copyright 2021 by Michiel de Hoon.  All rights reserved.
#
# This code is part of the Biopython distribution and governed by its
# license.  Please see the LICENSE file that should have been included
# as part of this package.
"""Tests for Bio.Align.tabular module."""
import unittest
import os

from Bio.Seq import Seq
from Bio import SeqIO
from Bio import Align


try:
    import numpy
except ImportError:
    from Bio import MissingPythonDependencyError

    raise MissingPythonDependencyError(
        "Install numpy if you want to use Bio.Align.emboss."
    ) from None


class TestFastaProtein(unittest.TestCase):

    query = Seq(
        "MPMILGYWNVRGLTHPIRMLLEYTDSSYDEKRYTMGDAPDFDRSQWLNEKFKLGLDFPNLPYLIDGSHKITQSNAILRYLARKHHLDGETEEERIRADIVENQVMDTRMQLIMLCYNPDFEKQKPEFLKTIPEKMKLYSEFLGKRPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKKISAYMKSSRYIATPIFSKMAHWSNK"
    )

    filename = os.path.join("Fasta", "protein_lib.fa")
    records = SeqIO.parse(filename, "fasta")
    targets = {record.id: record.seq.upper() for record in records}

    def test_m8CB(self):
        # Alignment file obtained by running
        # fasta36 -q -m 8CB seq/mgstm1.aa seq/prot_test.lseg
        # in the fasta36 source distribution
        path = "Fasta/protein_m8CB.txt"
        alignments = Align.parse(path, "tabular")
        self.assertEqual(
            alignments.metadata["Command line"],
            "fasta36 -q -m 8CB seq/mgstm1.aa seq/prot_test.lseg",
        )
        self.assertEqual(alignments.metadata["Program"], "FASTA")
        self.assertEqual(alignments.metadata["Version"], "36.3.8h May, 2020")
        self.assertEqual(alignments.metadata["Database"], "seq/prot_test.lseg")
        # sp|P10649|GSTM1_MOUSE   sp|P09488|GSTM1_HUMAN
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 77.98)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 218)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 218)
        self.assertEqual(alignment.shape, (2, 218 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P09488|GSTM1_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 48)
        self.assertAlmostEqual(alignment.annotations["evalue"], 6.1e-78)
        self.assertAlmostEqual(alignment.annotations["bit score"], 275.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[0, 218], [0, 218]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 218)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "MPMILGYWDIRGLAHAIRLLLEYTDSSYEEKKYTMGDAPDYDRSQWLNEKFKLGLDFPNLPYLIDGAHKITQSNAILCYIARKHNLCGETEEEKIRVDILENQTMDNHMQLGMICYNPEFEKLKPKYLEELPEKLKLYSEFLGKRPWFAGNKITFVDFLVYDVLDLHRIFEPKCLDAFPNLKDFISRFEGLEKISAYMKSSRFLPRPVFSKMAVWGNK",
        )
        self.assertEqual(
            alignment[1],
            "MPMILGYWNVRGLTHPIRMLLEYTDSSYDEKRYTMGDAPDFDRSQWLNEKFKLGLDFPNLPYLIDGSHKITQSNAILRYLARKHHLDGETEEERIRADIVENQVMDTRMQLIMLCYNPDFEKQKPEFLKTIPEKMKLYSEFLGKRPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKKISAYMKSSRYIATPIFSKMAHWSNK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P00502|GSTA1_RAT
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'D', 'I', 'R', 'G', 'L',
              'A', 'H', 'A', 'I', 'R', 'L', 'L', 'L', 'E', 'Y', 'T', 'D', 'S',
              'S', 'Y', 'E', 'E', 'K', 'K', 'Y', 'T', 'M', 'G', 'D', 'A', 'P',
              'D', 'Y', 'D', 'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K',
              'L', 'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D',
              'G', 'A', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'C',
              'Y', 'I', 'A', 'R', 'K', 'H', 'N', 'L', 'C', 'G', 'E', 'T', 'E',
              'E', 'E', 'K', 'I', 'R', 'V', 'D', 'I', 'L', 'E', 'N', 'Q', 'T',
              'M', 'D', 'N', 'H', 'M', 'Q', 'L', 'G', 'M', 'I', 'C', 'Y', 'N',
              'P', 'E', 'F', 'E', 'K', 'L', 'K', 'P', 'K', 'Y', 'L', 'E', 'E',
              'L', 'P', 'E', 'K', 'L', 'K', 'L', 'Y', 'S', 'E', 'F', 'L', 'G',
              'K', 'R', 'P', 'W', 'F', 'A', 'G', 'N', 'K', 'I', 'T', 'F', 'V',
              'D', 'F', 'L', 'V', 'Y', 'D', 'V', 'L', 'D', 'L', 'H', 'R', 'I',
              'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A', 'F', 'P', 'N', 'L', 'K',
              'D', 'F', 'I', 'S', 'R', 'F', 'E', 'G', 'L', 'E', 'K', 'I', 'S',
              'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'F', 'L', 'P', 'R', 'P', 'V',
              'F', 'S', 'K', 'M', 'A', 'V', 'W', 'G', 'N', 'K'],
             ['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'N', 'V', 'R', 'G', 'L',
              'T', 'H', 'P', 'I', 'R', 'M', 'L', 'L', 'E', 'Y', 'T', 'D', 'S',
              'S', 'Y', 'D', 'E', 'K', 'R', 'Y', 'T', 'M', 'G', 'D', 'A', 'P',
              'D', 'F', 'D', 'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K',
              'L', 'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D',
              'G', 'S', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'R',
              'Y', 'L', 'A', 'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E',
              'E', 'E', 'R', 'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V',
              'M', 'D', 'T', 'R', 'M', 'Q', 'L', 'I', 'M', 'L', 'C', 'Y', 'N',
              'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P', 'E', 'F', 'L', 'K', 'T',
              'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E', 'F', 'L', 'G',
              'K', 'R', 'P', 'W', 'F', 'A', 'G', 'D', 'K', 'V', 'T', 'Y', 'V',
              'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L', 'D', 'Q', 'Y', 'R', 'M',
              'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A', 'F', 'P', 'N', 'L', 'R',
              'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G', 'L', 'K', 'K', 'I', 'S',
              'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'Y', 'I', 'A', 'T', 'P', 'I',
              'F', 'S', 'K', 'M', 'A', 'H', 'W', 'S', 'N', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 29.76)
        self.assertEqual(alignment.annotations["gap opens"], 18)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 205)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 205)
        self.assertEqual(alignment.shape, (2, 205 + 18))
        self.assertEqual(alignment.sequences[0].id, "sp|P00502|GSTA1_RAT")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 144)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.1e-13)
        self.assertAlmostEqual(alignment.annotations["bit score"], 60.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 5,  33,  33,  46,  48,  58,  59,  62,
                              62, 101, 102, 125, 127, 142, 144, 218],
                             [ 3,  31,  40,  53,  53,  63,  63,  66,
                              67, 106, 106, 129, 129, 144, 144, 218]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 218)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "VLHYFNARGRMECIRWLLAAAGVEFDEK---------FIQSPEDLEKLKKDGNLMFDQVPMVEIDG-MKLAQTRAILNYIATKYDLYGKDMKERALIDMYTEGILDLTEMIMQLVICPPDQKEAKTALAKDRTKNRYLPAFEKVLKSHGQDYLVGNRLTRVDIHLLELLLYVEEFDASLLTSFPLLKAFKSRISSLPNVKKFLQPGSQRKLPVDAKQIEEARK",
        )
        self.assertEqual(
            alignment[1],
            "ILGYWNVRGLTHPIRMLLEYTDSSYDEKRYTMGDAPDFDRSQWLNEKFKL--GLDFPNLPYL-IDGSHKITQSNAILRYLARKHHLDGETEEERIRADIVENQVMD-TRMQLIMLCYNPDFEKQKPEFLK--TIPEKMKLYSEFLGK--RPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKKISAYMKSSRYIATPIFSKMAHWSNK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P69905|HBA_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['V', 'L', 'H', 'Y', 'F', 'N', 'A', 'R', 'G', 'R', 'M', 'E', 'C',
              'I', 'R', 'W', 'L', 'L', 'A', 'A', 'A', 'G', 'V', 'E', 'F', 'D',
              'E', 'K', '-', '-', '-', '-', '-', '-', '-', '-', '-', 'F', 'I',
              'Q', 'S', 'P', 'E', 'D', 'L', 'E', 'K', 'L', 'K', 'K', 'D', 'G',
              'N', 'L', 'M', 'F', 'D', 'Q', 'V', 'P', 'M', 'V', 'E', 'I', 'D',
              'G', '-', 'M', 'K', 'L', 'A', 'Q', 'T', 'R', 'A', 'I', 'L', 'N',
              'Y', 'I', 'A', 'T', 'K', 'Y', 'D', 'L', 'Y', 'G', 'K', 'D', 'M',
              'K', 'E', 'R', 'A', 'L', 'I', 'D', 'M', 'Y', 'T', 'E', 'G', 'I',
              'L', 'D', 'L', 'T', 'E', 'M', 'I', 'M', 'Q', 'L', 'V', 'I', 'C',
              'P', 'P', 'D', 'Q', 'K', 'E', 'A', 'K', 'T', 'A', 'L', 'A', 'K',
              'D', 'R', 'T', 'K', 'N', 'R', 'Y', 'L', 'P', 'A', 'F', 'E', 'K',
              'V', 'L', 'K', 'S', 'H', 'G', 'Q', 'D', 'Y', 'L', 'V', 'G', 'N',
              'R', 'L', 'T', 'R', 'V', 'D', 'I', 'H', 'L', 'L', 'E', 'L', 'L',
              'L', 'Y', 'V', 'E', 'E', 'F', 'D', 'A', 'S', 'L', 'L', 'T', 'S',
              'F', 'P', 'L', 'L', 'K', 'A', 'F', 'K', 'S', 'R', 'I', 'S', 'S',
              'L', 'P', 'N', 'V', 'K', 'K', 'F', 'L', 'Q', 'P', 'G', 'S', 'Q',
              'R', 'K', 'L', 'P', 'V', 'D', 'A', 'K', 'Q', 'I', 'E', 'E', 'A',
              'R', 'K'],
             ['I', 'L', 'G', 'Y', 'W', 'N', 'V', 'R', 'G', 'L', 'T', 'H', 'P',
              'I', 'R', 'M', 'L', 'L', 'E', 'Y', 'T', 'D', 'S', 'S', 'Y', 'D',
              'E', 'K', 'R', 'Y', 'T', 'M', 'G', 'D', 'A', 'P', 'D', 'F', 'D',
              'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K', 'L', '-', '-',
              'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', '-', 'I', 'D',
              'G', 'S', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'R',
              'Y', 'L', 'A', 'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E',
              'E', 'E', 'R', 'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V',
              'M', 'D', '-', 'T', 'R', 'M', 'Q', 'L', 'I', 'M', 'L', 'C', 'Y',
              'N', 'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P', 'E', 'F', 'L', 'K',
              '-', '-', 'T', 'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E',
              'F', 'L', 'G', 'K', '-', '-', 'R', 'P', 'W', 'F', 'A', 'G', 'D',
              'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L',
              'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A',
              'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G',
              'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'Y',
              'I', 'A', 'T', 'P', 'I', 'F', 'S', 'K', 'M', 'A', 'H', 'W', 'S',
              'N', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 27.03)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 37)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 37)
        self.assertEqual(alignment.shape, (2, 37 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P69905|HBA_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 27)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.19)
        self.assertAlmostEqual(alignment.annotations["bit score"], 20.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 35,  48,  48,  58,  59,  73],
                             [176, 189, 190, 200, 200, 214]]),
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 73)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "SFPTTKTYFPHFD-LSHGSAQVKGHGKKVADALTNAVAH")
        self.assertEqual(alignment[1], "AFPNLRDFLARFEGLKKISAYMKS-SRYIATPIFSKMAH")
        # sp|P10649|GSTM1_MOUSE   sp|P00517|KAPCA_BOVIN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['S', 'F', 'P', 'T', 'T', 'K', 'T', 'Y', 'F', 'P', 'H', 'F', 'D',
              '-', 'L', 'S', 'H', 'G', 'S', 'A', 'Q', 'V', 'K', 'G', 'H', 'G',
              'K', 'K', 'V', 'A', 'D', 'A', 'L', 'T', 'N', 'A', 'V', 'A', 'H'],
             ['A', 'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E',
              'G', 'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K', 'S', '-', 'S',
              'R', 'Y', 'I', 'A', 'T', 'P', 'I', 'F', 'S', 'K', 'M', 'A', 'H']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 24.29)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 70)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 70)
        self.assertEqual(alignment.shape, (2, 70 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P00517|KAPCA_BOVIN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 53)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.4)
        self.assertAlmostEqual(alignment.annotations["bit score"], 19.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[228, 274, 276, 300],
                             [136, 182, 182, 206]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 300)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "IYEMAAGYPPFFADQPIQIYEKIVSGKVRFPSHFSSDLKDLLRNLLQVDLTKRFGNLKNGVNDIKNHKWFAT",
        )
        self.assertEqual(
            alignment[1],
            "LYSEFLGKRPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLR--DFLARFEGLKKISAYMKSSRYIAT",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P14960|RBS_GUITH
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['I', 'Y', 'E', 'M', 'A', 'A', 'G', 'Y', 'P', 'P', 'F', 'F', 'A',
              'D', 'Q', 'P', 'I', 'Q', 'I', 'Y', 'E', 'K', 'I', 'V', 'S', 'G',
              'K', 'V', 'R', 'F', 'P', 'S', 'H', 'F', 'S', 'S', 'D', 'L', 'K',
              'D', 'L', 'L', 'R', 'N', 'L', 'L', 'Q', 'V', 'D', 'L', 'T', 'K',
              'R', 'F', 'G', 'N', 'L', 'K', 'N', 'G', 'V', 'N', 'D', 'I', 'K',
              'N', 'H', 'K', 'W', 'F', 'A', 'T'],
             ['L', 'Y', 'S', 'E', 'F', 'L', 'G', 'K', 'R', 'P', 'W', 'F', 'A',
              'G', 'D', 'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D',
              'I', 'L', 'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L',
              'D', 'A', 'F', 'P', 'N', 'L', 'R', '-', '-', 'D', 'F', 'L', 'A',
              'R', 'F', 'E', 'G', 'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K',
              'S', 'S', 'R', 'Y', 'I', 'A', 'T']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 57.14)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 7)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 7)
        self.assertEqual(alignment.shape, (2, 7 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P14960|RBS_GUITH")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 3)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.6)
        self.assertAlmostEqual(alignment.annotations["bit score"], 17.7)
        self.assertTrue(
            numpy.array_equal(alignment.coordinates, numpy.array([[46, 53], [6, 13]]))
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 53)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "YWDLWGL")
        self.assertEqual(alignment[1], "YWNVRGL")
        # sp|P10649|GSTM1_MOUSE   sp|P01593|KV101_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['Y', 'W', 'D', 'L', 'W', 'G', 'L'],
             ['Y', 'W', 'N', 'V', 'R', 'G', 'L']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 45.00)
        self.assertEqual(alignment.annotations["gap opens"], 10)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 40)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 40)
        self.assertEqual(alignment.shape, (2, 40 + 10))
        self.assertEqual(alignment.sequences[0].id, "sp|P01593|KV101_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 22)
        self.assertAlmostEqual(alignment.annotations["evalue"], 2.5)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 15,  29,  32,  40,  43,  47,
                               49,  51,  51,  58,  59,  64],
                             [149, 163, 163, 171, 171, 175,
                              175, 177, 178, 185, 185, 190]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 64)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0], "GDRVTITCQASQDINHYLNWYQQGPKKAPKILIYDA-SNLETGVPSRFSG"
        )
        self.assertEqual(
            alignment[1], "GDKVTYVDFLAYDI---LDQYRMFE---PKCL--DAFPNLRDFL-ARFEG"
        )
        # sp|P10649|GSTM1_MOUSE   sp|P99998|CYC_PANTR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'D', 'R', 'V', 'T', 'I', 'T', 'C', 'Q', 'A', 'S', 'Q', 'D',
              'I', 'N', 'H', 'Y', 'L', 'N', 'W', 'Y', 'Q', 'Q', 'G', 'P', 'K',
              'K', 'A', 'P', 'K', 'I', 'L', 'I', 'Y', 'D', 'A', '-', 'S', 'N',
              'L', 'E', 'T', 'G', 'V', 'P', 'S', 'R', 'F', 'S', 'G'],
             ['G', 'D', 'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D',
              'I', '-', '-', '-', 'L', 'D', 'Q', 'Y', 'R', 'M', 'F', 'E', '-',
              '-', '-', 'P', 'K', 'C', 'L', '-', '-', 'D', 'A', 'F', 'P', 'N',
              'L', 'R', 'D', 'F', 'L', '-', 'A', 'R', 'F', 'E', 'G']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 31.03)
        self.assertEqual(alignment.annotations["gap opens"], 10)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 58)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 58)
        self.assertEqual(alignment.shape, (2, 58 + 10))
        self.assertEqual(alignment.sequences[0].id, "sp|P99998|CYC_PANTR")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 40)
        self.assertAlmostEqual(alignment.annotations["evalue"], 2.7)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.4)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 27,  47,  50,  58,  58,  68,
                               68,  73,  73,  82,  82,  88],
                             [128, 148, 148, 156, 157, 167,
                              168, 173, 175, 184, 187, 193]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 88)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "KTGPNLHGLFGRKTGQAPGYSYTAANKNKGI-IWGEDTLMEY-LENPK--KYIPGTKMI---FVGIKK",
        )
        self.assertEqual(
            alignment[1],
            "KTIPEKMKLYSEFLGKRPWF---AGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P02585|TNNC2_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['K', 'T', 'G', 'P', 'N', 'L', 'H', 'G', 'L', 'F', 'G', 'R', 'K',
              'T', 'G', 'Q', 'A', 'P', 'G', 'Y', 'S', 'Y', 'T', 'A', 'A', 'N',
              'K', 'N', 'K', 'G', 'I', '-', 'I', 'W', 'G', 'E', 'D', 'T', 'L',
              'M', 'E', 'Y', '-', 'L', 'E', 'N', 'P', 'K', '-', '-', 'K', 'Y',
              'I', 'P', 'G', 'T', 'K', 'M', 'I', '-', '-', '-', 'F', 'V', 'G',
              'I', 'K', 'K'],
             ['K', 'T', 'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E', 'F',
              'L', 'G', 'K', 'R', 'P', 'W', 'F', '-', '-', '-', 'A', 'G', 'D',
              'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L',
              'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A',
              'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G',
              'L', 'K', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 31.11)
        self.assertEqual(alignment.annotations["gap opens"], 9)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 45)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 45)
        self.assertEqual(alignment.shape, (2, 45 + 9))
        self.assertEqual(alignment.sequences[0].id, "sp|P02585|TNNC2_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 31)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.9)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.4)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array(
                    [[12, 26, 26, 36, 38, 49, 52, 62],
                     [43, 57, 61, 71, 71, 82, 82, 92]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 62)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0], "SEEMIAEFKAAFDM----FDADGGGDISVKELGTVMRMLGQTPTKEELDAIIEE"
        )
        self.assertEqual(
            alignment[1], "SQWLNEKFKLGLDFPNLPYLIDGSHKIT--QSNAILRYLAR---KHHLDGETEE"
        )
        # sp|P10649|GSTM1_MOUSE   sp|P60615|NXL1A_BUNMU
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['S', 'E', 'E', 'M', 'I', 'A', 'E', 'F', 'K', 'A', 'A', 'F', 'D',
              'M', '-', '-', '-', '-', 'F', 'D', 'A', 'D', 'G', 'G', 'G', 'D',
              'I', 'S', 'V', 'K', 'E', 'L', 'G', 'T', 'V', 'M', 'R', 'M', 'L',
              'G', 'Q', 'T', 'P', 'T', 'K', 'E', 'E', 'L', 'D', 'A', 'I', 'I',
              'E', 'E'],
             ['S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K', 'L', 'G', 'L', 'D',
              'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D', 'G', 'S', 'H', 'K',
              'I', 'T', '-', '-', 'Q', 'S', 'N', 'A', 'I', 'L', 'R', 'Y', 'L',
              'A', 'R', '-', '-', '-', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T',
              'E', 'E']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 66.67)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 9)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 9)
        self.assertEqual(alignment.shape, (2, 9 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P60615|NXL1A_BUNMU")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 3)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.2)
        self.assertAlmostEqual(alignment.annotations["bit score"], 15.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 85,  86,  86,  89,  89,  94],
                             [114, 115, 116, 119, 120, 125]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 94)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "C-NPH-PKQRP")
        self.assertEqual(alignment[1], "CYNPDFEKQKP")
        # sp|P10649|GSTM1_MOUSE   sp|P00193|FER_PEPAS
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', '-', 'N', 'P', 'H', '-', 'P', 'K', 'Q', 'R', 'P'],
             ['C', 'Y', 'N', 'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 50.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 4)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 4)
        self.assertEqual(alignment.shape, (2, 4 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P00193|FER_PEPAS")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.2)
        self.assertAlmostEqual(alignment.annotations["bit score"], 14.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[14, 18], [170, 174]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 18)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "KPEC")
        self.assertEqual(alignment[1], "EPKC")
        # sp|P10649|GSTM1_MOUSE   sp|P03435|HEMA_I75A3
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['K', 'P', 'E', 'C'],
             ['E', 'P', 'K', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 28.95)
        self.assertEqual(alignment.annotations["gap opens"], 1)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 38)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 38)
        self.assertEqual(alignment.shape, (2, 38 + 1))
        self.assertEqual(alignment.sequences[0].id, "sp|P03435|HEMA_I75A3")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 27)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.7)
        self.assertAlmostEqual(alignment.annotations["bit score"], 17.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[398, 408, 409, 437], [73, 83, 83, 111]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 437)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "NRVIEKTNEKFHQIEKEFSEVEGRIQDLEKYVEDTKIDL")
        self.assertEqual(alignment[1], "NAILRYLARK-HHLDGETEEERIRADIVENQVMDTRMQL")
        # sp|P10649|GSTM1_MOUSE   sp|P01834|IGKC_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['N', 'R', 'V', 'I', 'E', 'K', 'T', 'N', 'E', 'K', 'F', 'H', 'Q',
              'I', 'E', 'K', 'E', 'F', 'S', 'E', 'V', 'E', 'G', 'R', 'I', 'Q',
              'D', 'L', 'E', 'K', 'Y', 'V', 'E', 'D', 'T', 'K', 'I', 'D', 'L'],
             ['N', 'A', 'I', 'L', 'R', 'Y', 'L', 'A', 'R', 'K', '-', 'H', 'H',
              'L', 'D', 'G', 'E', 'T', 'E', 'E', 'E', 'R', 'I', 'R', 'A', 'D',
              'I', 'V', 'E', 'N', 'Q', 'V', 'M', 'D', 'T', 'R', 'M', 'Q', 'L']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 19.40)
        self.assertEqual(alignment.annotations["gap opens"], 4)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 67)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 67)
        self.assertEqual(alignment.shape, (2, 67 + 4))
        self.assertEqual(alignment.sequences[0].id, "sp|P01834|IGKC_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 54)
        self.assertAlmostEqual(alignment.annotations["evalue"], 6.3)
        self.assertAlmostEqual(alignment.annotations["bit score"], 14.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[11, 25, 27,  67,  69,  82],
                             [57, 71, 71, 111, 111, 124]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 82)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "PSDEQLKSGTASVVCLLNNFYPREAKVQWKVDNALQSGNSQESVTEQDSKDSTYSLSSTLTLSKADYEKHK",
        )
        self.assertEqual(
            alignment[1],
            "PNLPYLIDGSHKIT--QSNAILRYLARKHHLDGETEEERIRADIVENQVMDTRMQL--IMLCYNPDFEKQK",
        )
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['P', 'S', 'D', 'E', 'Q', 'L', 'K', 'S', 'G', 'T', 'A', 'S', 'V',
              'V', 'C', 'L', 'L', 'N', 'N', 'F', 'Y', 'P', 'R', 'E', 'A', 'K',
              'V', 'Q', 'W', 'K', 'V', 'D', 'N', 'A', 'L', 'Q', 'S', 'G', 'N',
              'S', 'Q', 'E', 'S', 'V', 'T', 'E', 'Q', 'D', 'S', 'K', 'D', 'S',
              'T', 'Y', 'S', 'L', 'S', 'S', 'T', 'L', 'T', 'L', 'S', 'K', 'A',
              'D', 'Y', 'E', 'K', 'H', 'K'],
             ['P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D', 'G', 'S', 'H', 'K', 'I',
              'T', '-', '-', 'Q', 'S', 'N', 'A', 'I', 'L', 'R', 'Y', 'L', 'A',
              'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E', 'E', 'E', 'R',
              'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V', 'M', 'D', 'T',
              'R', 'M', 'Q', 'L', '-', '-', 'I', 'M', 'L', 'C', 'Y', 'N', 'P',
              'D', 'F', 'E', 'K', 'Q', 'K']], dtype='U')
                # fmt: on
            )
        )
        with self.assertRaises(StopIteration):
            next(alignments)

    def test_m8CC(self):
        # Alignment file obtained by running
        # fasta36 -q -m 8CB seq/mgstm1.aa seq/prot_test.lseg
        # in the fasta36 source distribution
        path = "Fasta/protein_m8CC.txt"
        alignments = Align.parse(path, "tabular")
        self.assertEqual(
            alignments.metadata["Command line"],
            "fasta36 -q -m 8CC seq/mgstm1.aa seq/prot_test.lseg",
        )
        self.assertEqual(alignments.metadata["Program"], "FASTA")
        self.assertEqual(alignments.metadata["Version"], "36.3.8h May, 2020")
        self.assertEqual(alignments.metadata["Database"], "seq/prot_test.lseg")
        # sp|P10649|GSTM1_MOUSE   sp|P09488|GSTM1_HUMAN
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 77.98)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 218)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 218)
        self.assertEqual(alignment.shape, (2, 218 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P09488|GSTM1_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 48)
        self.assertAlmostEqual(alignment.annotations["evalue"], 7.6e-83)
        self.assertAlmostEqual(alignment.annotations["bit score"], 291.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[0, 218], [0, 218]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 218)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "MPMILGYWDIRGLAHAIRLLLEYTDSSYEEKKYTMGDAPDYDRSQWLNEKFKLGLDFPNLPYLIDGAHKITQSNAILCYIARKHNLCGETEEEKIRVDILENQTMDNHMQLGMICYNPEFEKLKPKYLEELPEKLKLYSEFLGKRPWFAGNKITFVDFLVYDVLDLHRIFEPKCLDAFPNLKDFISRFEGLEKISAYMKSSRFLPRPVFSKMAVWGNK",
        )
        self.assertEqual(
            alignment[1],
            "MPMILGYWNVRGLTHPIRMLLEYTDSSYDEKRYTMGDAPDFDRSQWLNEKFKLGLDFPNLPYLIDGSHKITQSNAILRYLARKHHLDGETEEERIRADIVENQVMDTRMQLIMLCYNPDFEKQKPEFLKTIPEKMKLYSEFLGKRPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKKISAYMKSSRYIATPIFSKMAHWSNK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P00502|GSTA1_RAT
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'D', 'I', 'R', 'G', 'L',
              'A', 'H', 'A', 'I', 'R', 'L', 'L', 'L', 'E', 'Y', 'T', 'D', 'S',
              'S', 'Y', 'E', 'E', 'K', 'K', 'Y', 'T', 'M', 'G', 'D', 'A', 'P',
              'D', 'Y', 'D', 'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K',
              'L', 'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D',
              'G', 'A', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'C',
              'Y', 'I', 'A', 'R', 'K', 'H', 'N', 'L', 'C', 'G', 'E', 'T', 'E',
              'E', 'E', 'K', 'I', 'R', 'V', 'D', 'I', 'L', 'E', 'N', 'Q', 'T',
              'M', 'D', 'N', 'H', 'M', 'Q', 'L', 'G', 'M', 'I', 'C', 'Y', 'N',
              'P', 'E', 'F', 'E', 'K', 'L', 'K', 'P', 'K', 'Y', 'L', 'E', 'E',
              'L', 'P', 'E', 'K', 'L', 'K', 'L', 'Y', 'S', 'E', 'F', 'L', 'G',
              'K', 'R', 'P', 'W', 'F', 'A', 'G', 'N', 'K', 'I', 'T', 'F', 'V',
              'D', 'F', 'L', 'V', 'Y', 'D', 'V', 'L', 'D', 'L', 'H', 'R', 'I',
              'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A', 'F', 'P', 'N', 'L', 'K',
              'D', 'F', 'I', 'S', 'R', 'F', 'E', 'G', 'L', 'E', 'K', 'I', 'S',
              'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'F', 'L', 'P', 'R', 'P', 'V',
              'F', 'S', 'K', 'M', 'A', 'V', 'W', 'G', 'N', 'K'],
             ['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'N', 'V', 'R', 'G', 'L',
              'T', 'H', 'P', 'I', 'R', 'M', 'L', 'L', 'E', 'Y', 'T', 'D', 'S',
              'S', 'Y', 'D', 'E', 'K', 'R', 'Y', 'T', 'M', 'G', 'D', 'A', 'P',
              'D', 'F', 'D', 'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K',
              'L', 'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D',
              'G', 'S', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'R',
              'Y', 'L', 'A', 'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E',
              'E', 'E', 'R', 'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V',
              'M', 'D', 'T', 'R', 'M', 'Q', 'L', 'I', 'M', 'L', 'C', 'Y', 'N',
              'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P', 'E', 'F', 'L', 'K', 'T',
              'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E', 'F', 'L', 'G',
              'K', 'R', 'P', 'W', 'F', 'A', 'G', 'D', 'K', 'V', 'T', 'Y', 'V',
              'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L', 'D', 'Q', 'Y', 'R', 'M',
              'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A', 'F', 'P', 'N', 'L', 'R',
              'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G', 'L', 'K', 'K', 'I', 'S',
              'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'Y', 'I', 'A', 'T', 'P', 'I',
              'F', 'S', 'K', 'M', 'A', 'H', 'W', 'S', 'N', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 29.76)
        self.assertEqual(alignment.annotations["gap opens"], 18)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 205)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 205)
        self.assertEqual(alignment.shape, (2, 205 + 18))
        self.assertEqual(alignment.sequences[0].id, "sp|P00502|GSTA1_RAT")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 144)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.4e-14)
        self.assertAlmostEqual(alignment.annotations["bit score"], 63.5)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 5,  33,  33,  46,  48,  58,  59,  62,
                              62, 101, 102, 125, 127, 142, 144, 218],
                             [ 3,  31,  40,  53,  53,  63,  63,  66,
                              67, 106, 106, 129, 129, 144, 144, 218]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 218)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "VLHYFNARGRMECIRWLLAAAGVEFDEK---------FIQSPEDLEKLKKDGNLMFDQVPMVEIDG-MKLAQTRAILNYIATKYDLYGKDMKERALIDMYTEGILDLTEMIMQLVICPPDQKEAKTALAKDRTKNRYLPAFEKVLKSHGQDYLVGNRLTRVDIHLLELLLYVEEFDASLLTSFPLLKAFKSRISSLPNVKKFLQPGSQRKLPVDAKQIEEARK",
        )
        self.assertEqual(
            alignment[1],
            "ILGYWNVRGLTHPIRMLLEYTDSSYDEKRYTMGDAPDFDRSQWLNEKFKL--GLDFPNLPYL-IDGSHKITQSNAILRYLARKHHLDGETEEERIRADIVENQVMD-TRMQLIMLCYNPDFEKQKPEFLK--TIPEKMKLYSEFLGK--RPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKKISAYMKSSRYIATPIFSKMAHWSNK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P69905|HBA_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['V', 'L', 'H', 'Y', 'F', 'N', 'A', 'R', 'G', 'R', 'M', 'E', 'C',
              'I', 'R', 'W', 'L', 'L', 'A', 'A', 'A', 'G', 'V', 'E', 'F', 'D',
              'E', 'K', '-', '-', '-', '-', '-', '-', '-', '-', '-', 'F', 'I',
              'Q', 'S', 'P', 'E', 'D', 'L', 'E', 'K', 'L', 'K', 'K', 'D', 'G',
              'N', 'L', 'M', 'F', 'D', 'Q', 'V', 'P', 'M', 'V', 'E', 'I', 'D',
              'G', '-', 'M', 'K', 'L', 'A', 'Q', 'T', 'R', 'A', 'I', 'L', 'N',
              'Y', 'I', 'A', 'T', 'K', 'Y', 'D', 'L', 'Y', 'G', 'K', 'D', 'M',
              'K', 'E', 'R', 'A', 'L', 'I', 'D', 'M', 'Y', 'T', 'E', 'G', 'I',
              'L', 'D', 'L', 'T', 'E', 'M', 'I', 'M', 'Q', 'L', 'V', 'I', 'C',
              'P', 'P', 'D', 'Q', 'K', 'E', 'A', 'K', 'T', 'A', 'L', 'A', 'K',
              'D', 'R', 'T', 'K', 'N', 'R', 'Y', 'L', 'P', 'A', 'F', 'E', 'K',
              'V', 'L', 'K', 'S', 'H', 'G', 'Q', 'D', 'Y', 'L', 'V', 'G', 'N',
              'R', 'L', 'T', 'R', 'V', 'D', 'I', 'H', 'L', 'L', 'E', 'L', 'L',
              'L', 'Y', 'V', 'E', 'E', 'F', 'D', 'A', 'S', 'L', 'L', 'T', 'S',
              'F', 'P', 'L', 'L', 'K', 'A', 'F', 'K', 'S', 'R', 'I', 'S', 'S',
              'L', 'P', 'N', 'V', 'K', 'K', 'F', 'L', 'Q', 'P', 'G', 'S', 'Q',
              'R', 'K', 'L', 'P', 'V', 'D', 'A', 'K', 'Q', 'I', 'E', 'E', 'A',
              'R', 'K'],
             ['I', 'L', 'G', 'Y', 'W', 'N', 'V', 'R', 'G', 'L', 'T', 'H', 'P',
              'I', 'R', 'M', 'L', 'L', 'E', 'Y', 'T', 'D', 'S', 'S', 'Y', 'D',
              'E', 'K', 'R', 'Y', 'T', 'M', 'G', 'D', 'A', 'P', 'D', 'F', 'D',
              'R', 'S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K', 'L', '-', '-',
              'G', 'L', 'D', 'F', 'P', 'N', 'L', 'P', 'Y', 'L', '-', 'I', 'D',
              'G', 'S', 'H', 'K', 'I', 'T', 'Q', 'S', 'N', 'A', 'I', 'L', 'R',
              'Y', 'L', 'A', 'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E',
              'E', 'E', 'R', 'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V',
              'M', 'D', '-', 'T', 'R', 'M', 'Q', 'L', 'I', 'M', 'L', 'C', 'Y',
              'N', 'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P', 'E', 'F', 'L', 'K',
              '-', '-', 'T', 'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E',
              'F', 'L', 'G', 'K', '-', '-', 'R', 'P', 'W', 'F', 'A', 'G', 'D',
              'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L',
              'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A',
              'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G',
              'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K', 'S', 'S', 'R', 'Y',
              'I', 'A', 'T', 'P', 'I', 'F', 'S', 'K', 'M', 'A', 'H', 'W', 'S',
              'N', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 27.03)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 37)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 37)
        self.assertEqual(alignment.shape, (2, 37 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P69905|HBA_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 27)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.15)
        self.assertAlmostEqual(alignment.annotations["bit score"], 21.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 35,  48,  48,  58,  59,  73],
                             [176, 189, 190, 200, 200, 214]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 73)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "SFPTTKTYFPHFD-LSHGSAQVKGHGKKVADALTNAVAH")
        self.assertEqual(alignment[1], "AFPNLRDFLARFEGLKKISAYMKS-SRYIATPIFSKMAH")
        # sp|P10649|GSTM1_MOUSE   sp|P00517|KAPCA_BOVIN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['S', 'F', 'P', 'T', 'T', 'K', 'T', 'Y', 'F', 'P', 'H', 'F', 'D',
              '-', 'L', 'S', 'H', 'G', 'S', 'A', 'Q', 'V', 'K', 'G', 'H', 'G',
              'K', 'K', 'V', 'A', 'D', 'A', 'L', 'T', 'N', 'A', 'V', 'A', 'H'],
             ['A', 'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E',
              'G', 'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K', 'S', '-', 'S',
              'R', 'Y', 'I', 'A', 'T', 'P', 'I', 'F', 'S', 'K', 'M', 'A', 'H']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 24.29)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 70)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 70)
        self.assertEqual(alignment.shape, (2, 70 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P00517|KAPCA_BOVIN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 53)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.2)
        self.assertAlmostEqual(alignment.annotations["bit score"], 19.4)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[228, 274, 276, 300],
                             [136, 182, 182, 206]]),
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 300)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "IYEMAAGYPPFFADQPIQIYEKIVSGKVRFPSHFSSDLKDLLRNLLQVDLTKRFGNLKNGVNDIKNHKWFAT",
        )
        self.assertEqual(
            alignment[1],
            "LYSEFLGKRPWFAGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLR--DFLARFEGLKKISAYMKSSRYIAT",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P14960|RBS_GUITH
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['I', 'Y', 'E', 'M', 'A', 'A', 'G', 'Y', 'P', 'P', 'F', 'F', 'A',
              'D', 'Q', 'P', 'I', 'Q', 'I', 'Y', 'E', 'K', 'I', 'V', 'S', 'G',
              'K', 'V', 'R', 'F', 'P', 'S', 'H', 'F', 'S', 'S', 'D', 'L', 'K',
              'D', 'L', 'L', 'R', 'N', 'L', 'L', 'Q', 'V', 'D', 'L', 'T', 'K',
              'R', 'F', 'G', 'N', 'L', 'K', 'N', 'G', 'V', 'N', 'D', 'I', 'K',
              'N', 'H', 'K', 'W', 'F', 'A', 'T'],
             ['L', 'Y', 'S', 'E', 'F', 'L', 'G', 'K', 'R', 'P', 'W', 'F', 'A',
              'G', 'D', 'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D',
              'I', 'L', 'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L',
              'D', 'A', 'F', 'P', 'N', 'L', 'R', '-', '-', 'D', 'F', 'L', 'A',
              'R', 'F', 'E', 'G', 'L', 'K', 'K', 'I', 'S', 'A', 'Y', 'M', 'K',
              'S', 'S', 'R', 'Y', 'I', 'A', 'T']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 57.14)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 7)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 7)
        self.assertEqual(alignment.shape, (2, 7 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P14960|RBS_GUITH")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 3)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.5)
        self.assertAlmostEqual(alignment.annotations["bit score"], 17.8)
        self.assertTrue(
            numpy.array_equal(alignment.coordinates, numpy.array([[46, 53], [6, 13]]))
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 53)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "YWDLWGL")
        self.assertEqual(alignment[1], "YWNVRGL")
        # sp|P10649|GSTM1_MOUSE   sp|P01593|KV101_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['Y', 'W', 'D', 'L', 'W', 'G', 'L'],
             ['Y', 'W', 'N', 'V', 'R', 'G', 'L']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 45.00)
        self.assertEqual(alignment.annotations["gap opens"], 10)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 40)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 40)
        self.assertEqual(alignment.shape, (2, 40 + 10))
        self.assertEqual(alignment.sequences[0].id, "sp|P01593|KV101_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 22)
        self.assertAlmostEqual(alignment.annotations["evalue"], 2.4)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[15,  29,  32,  40,  43,  47,
                              49,  51,  51,  58,  59,  64],
                            [149, 163, 163, 171, 171, 175,
                             175, 177, 178, 185, 185, 190]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 64)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0], "GDRVTITCQASQDINHYLNWYQQGPKKAPKILIYDA-SNLETGVPSRFSG"
        )
        self.assertEqual(
            alignment[1], "GDKVTYVDFLAYDI---LDQYRMFE---PKCL--DAFPNLRDFL-ARFEG"
        )
        # sp|P10649|GSTM1_MOUSE   sp|P99998|CYC_PANTR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'D', 'R', 'V', 'T', 'I', 'T', 'C', 'Q', 'A', 'S', 'Q', 'D',
              'I', 'N', 'H', 'Y', 'L', 'N', 'W', 'Y', 'Q', 'Q', 'G', 'P', 'K',
              'K', 'A', 'P', 'K', 'I', 'L', 'I', 'Y', 'D', 'A', '-', 'S', 'N',
              'L', 'E', 'T', 'G', 'V', 'P', 'S', 'R', 'F', 'S', 'G'],
             ['G', 'D', 'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D',
              'I', '-', '-', '-', 'L', 'D', 'Q', 'Y', 'R', 'M', 'F', 'E', '-',
              '-', '-', 'P', 'K', 'C', 'L', '-', '-', 'D', 'A', 'F', 'P', 'N',
              'L', 'R', 'D', 'F', 'L', '-', 'A', 'R', 'F', 'E', 'G']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 31.03)
        self.assertEqual(alignment.annotations["gap opens"], 10)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 58)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 58)
        self.assertEqual(alignment.shape, (2, 58 + 10))
        self.assertEqual(alignment.sequences[0].id, "sp|P99998|CYC_PANTR")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 40)
        self.assertAlmostEqual(alignment.annotations["evalue"], 2.7)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.5)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 27,  47,  50,  58,  58,  68,
                               68,  73,  73,  82,  82,  88],
                             [128, 148, 148, 156, 157, 167,
                              168, 173, 175, 184, 187, 193]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 88)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "KTGPNLHGLFGRKTGQAPGYSYTAANKNKGI-IWGEDTLMEY-LENPK--KYIPGTKMI---FVGIKK",
        )
        self.assertEqual(
            alignment[1],
            "KTIPEKMKLYSEFLGKRPWF---AGDKVTYVDFLAYDILDQYRMFEPKCLDAFPNLRDFLARFEGLKK",
        )
        # sp|P10649|GSTM1_MOUSE   sp|P02585|TNNC2_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['K', 'T', 'G', 'P', 'N', 'L', 'H', 'G', 'L', 'F', 'G', 'R', 'K',
              'T', 'G', 'Q', 'A', 'P', 'G', 'Y', 'S', 'Y', 'T', 'A', 'A', 'N',
              'K', 'N', 'K', 'G', 'I', '-', 'I', 'W', 'G', 'E', 'D', 'T', 'L',
              'M', 'E', 'Y', '-', 'L', 'E', 'N', 'P', 'K', '-', '-', 'K', 'Y',
              'I', 'P', 'G', 'T', 'K', 'M', 'I', '-', '-', '-', 'F', 'V', 'G',
              'I', 'K', 'K'],
             ['K', 'T', 'I', 'P', 'E', 'K', 'M', 'K', 'L', 'Y', 'S', 'E', 'F',
              'L', 'G', 'K', 'R', 'P', 'W', 'F', '-', '-', '-', 'A', 'G', 'D',
              'K', 'V', 'T', 'Y', 'V', 'D', 'F', 'L', 'A', 'Y', 'D', 'I', 'L',
              'D', 'Q', 'Y', 'R', 'M', 'F', 'E', 'P', 'K', 'C', 'L', 'D', 'A',
              'F', 'P', 'N', 'L', 'R', 'D', 'F', 'L', 'A', 'R', 'F', 'E', 'G',
              'L', 'K', 'K']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 31.11)
        self.assertEqual(alignment.annotations["gap opens"], 9)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 45)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 45)
        self.assertEqual(alignment.shape, (2, 45 + 9))
        self.assertEqual(alignment.sequences[0].id, "sp|P02585|TNNC2_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 31)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.8)
        self.assertAlmostEqual(alignment.annotations["bit score"], 16.5)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[12, 26, 26, 36, 38, 49, 52, 62],
                             [43, 57, 61, 71, 71, 82, 82, 92]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 62)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0], "SEEMIAEFKAAFDM----FDADGGGDISVKELGTVMRMLGQTPTKEELDAIIEE"
        )
        self.assertEqual(
            alignment[1], "SQWLNEKFKLGLDFPNLPYLIDGSHKIT--QSNAILRYLAR---KHHLDGETEE"
        )
        # sp|P10649|GSTM1_MOUSE   sp|P60615|NXL1A_BUNMU
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['S', 'E', 'E', 'M', 'I', 'A', 'E', 'F', 'K', 'A', 'A', 'F', 'D',
              'M', '-', '-', '-', '-', 'F', 'D', 'A', 'D', 'G', 'G', 'G', 'D',
              'I', 'S', 'V', 'K', 'E', 'L', 'G', 'T', 'V', 'M', 'R', 'M', 'L',
              'G', 'Q', 'T', 'P', 'T', 'K', 'E', 'E', 'L', 'D', 'A', 'I', 'I',
              'E', 'E'],
             ['S', 'Q', 'W', 'L', 'N', 'E', 'K', 'F', 'K', 'L', 'G', 'L', 'D',
              'F', 'P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D', 'G', 'S', 'H', 'K',
              'I', 'T', '-', '-', 'Q', 'S', 'N', 'A', 'I', 'L', 'R', 'Y', 'L',
              'A', 'R', '-', '-', '-', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T',
              'E', 'E']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 66.67)
        self.assertEqual(alignment.annotations["gap opens"], 2)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 9)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 9)
        self.assertEqual(alignment.shape, (2, 9 + 2))
        self.assertEqual(alignment.sequences[0].id, "sp|P60615|NXL1A_BUNMU")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 3)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.2)
        self.assertAlmostEqual(alignment.annotations["bit score"], 15.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[ 85,  86,  86,  89,  89,  94],
                             [114, 115, 116, 119, 120, 125]]),
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 94)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "C-NPH-PKQRP")
        self.assertEqual(alignment[1], "CYNPDFEKQKP")
        # sp|P10649|GSTM1_MOUSE   sp|P03435|HEMA_I75A3
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', '-', 'N', 'P', 'H', '-', 'P', 'K', 'Q', 'R', 'P'],
             ['C', 'Y', 'N', 'P', 'D', 'F', 'E', 'K', 'Q', 'K', 'P']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 28.95)
        self.assertEqual(alignment.annotations["gap opens"], 1)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 38)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 38)
        self.assertEqual(alignment.shape, (2, 38 + 1))
        self.assertEqual(alignment.sequences[0].id, "sp|P03435|HEMA_I75A3")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 27)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.4)
        self.assertAlmostEqual(alignment.annotations["bit score"], 18.1)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[398, 408, 409, 437],
                             [ 73,  83,  83, 111]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 437)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "NRVIEKTNEKFHQIEKEFSEVEGRIQDLEKYVEDTKIDL")
        self.assertEqual(alignment[1], "NAILRYLARK-HHLDGETEEERIRADIVENQVMDTRMQL")
        # sp|P10649|GSTM1_MOUSE   sp|P00193|FER_PEPAS
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['N', 'R', 'V', 'I', 'E', 'K', 'T', 'N', 'E', 'K', 'F', 'H', 'Q',
              'I', 'E', 'K', 'E', 'F', 'S', 'E', 'V', 'E', 'G', 'R', 'I', 'Q',
              'D', 'L', 'E', 'K', 'Y', 'V', 'E', 'D', 'T', 'K', 'I', 'D', 'L'],
             ['N', 'A', 'I', 'L', 'R', 'Y', 'L', 'A', 'R', 'K', '-', 'H', 'H',
              'L', 'D', 'G', 'E', 'T', 'E', 'E', 'E', 'R', 'I', 'R', 'A', 'D',
              'I', 'V', 'E', 'N', 'Q', 'V', 'M', 'D', 'T', 'R', 'M', 'Q', 'L']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 50.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 4)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 4)
        self.assertEqual(alignment.shape, (2, 4 + 0))
        self.assertEqual(alignment.sequences[0].id, "sp|P00193|FER_PEPAS")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 4.4)
        self.assertAlmostEqual(alignment.annotations["bit score"], 14.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[14, 18], [170, 174]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 18)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "KPEC")
        self.assertEqual(alignment[1], "EPKC")
        # sp|P10649|GSTM1_MOUSE   sp|P01834|IGKC_HUMAN
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['K', 'P', 'E', 'C'],
             ['E', 'P', 'K', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 19.40)
        self.assertEqual(alignment.annotations["gap opens"], 4)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 67)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 67)
        self.assertEqual(alignment.shape, (2, 67 + 4))
        self.assertEqual(alignment.sequences[0].id, "sp|P01834|IGKC_HUMAN")
        self.assertEqual(alignment.sequences[1].id, "sp|P10649|GSTM1_MOUSE")
        self.assertEqual(alignment.annotations["mismatches"], 54)
        self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
        self.assertAlmostEqual(alignment.annotations["bit score"], 14.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[11, 25, 27,  67,  69,  82],
                             [57, 71, 71, 111, 111, 124]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 82)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "PSDEQLKSGTASVVCLLNNFYPREAKVQWKVDNALQSGNSQESVTEQDSKDSTYSLSSTLTLSKADYEKHK",
        )
        self.assertEqual(
            alignment[1],
            "PNLPYLIDGSHKIT--QSNAILRYLARKHHLDGETEEERIRADIVENQVMDTRMQL--IMLCYNPDFEKQK",
        )
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['P', 'S', 'D', 'E', 'Q', 'L', 'K', 'S', 'G', 'T', 'A', 'S', 'V',
              'V', 'C', 'L', 'L', 'N', 'N', 'F', 'Y', 'P', 'R', 'E', 'A', 'K',
              'V', 'Q', 'W', 'K', 'V', 'D', 'N', 'A', 'L', 'Q', 'S', 'G', 'N',
              'S', 'Q', 'E', 'S', 'V', 'T', 'E', 'Q', 'D', 'S', 'K', 'D', 'S',
              'T', 'Y', 'S', 'L', 'S', 'S', 'T', 'L', 'T', 'L', 'S', 'K', 'A',
              'D', 'Y', 'E', 'K', 'H', 'K'],
             ['P', 'N', 'L', 'P', 'Y', 'L', 'I', 'D', 'G', 'S', 'H', 'K', 'I',
              'T', '-', '-', 'Q', 'S', 'N', 'A', 'I', 'L', 'R', 'Y', 'L', 'A',
              'R', 'K', 'H', 'H', 'L', 'D', 'G', 'E', 'T', 'E', 'E', 'E', 'R',
              'I', 'R', 'A', 'D', 'I', 'V', 'E', 'N', 'Q', 'V', 'M', 'D', 'T',
              'R', 'M', 'Q', 'L', '-', '-', 'I', 'M', 'L', 'C', 'Y', 'N', 'P',
              'D', 'F', 'E', 'K', 'Q', 'K']], dtype='U')
                # fmt: on
            )
        )
        with self.assertRaises(StopIteration):
            next(alignments)


class TestFastaNucleotide(unittest.TestCase):

    query = Seq(
        "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGAGTAACAAGTAG"
    )

    filename = os.path.join("Fasta", "nucleotide_lib.fa")
    records = SeqIO.parse(filename, "fasta")
    targets = {record.id: record.seq.upper() for record in records}

    def test_m8CB(self):
        # Alignment file obtained by running
        # fasta36 -m 8CB seq/mgstm1.nt seq/gst.nlib
        # in the fasta36 source distribution
        path = "Fasta/nucleotide_m8CB.txt"
        alignments = Align.parse(path, "tabular")
        self.assertEqual(
            alignments.metadata["Command line"],
            "fasta36 -m 8CB seq/mgstm1.nt seq/gst.nlib",
        )
        self.assertEqual(alignments.metadata["Program"], "FASTA")
        self.assertEqual(alignments.metadata["Version"], "36.3.8h May, 2020")
        self.assertEqual(alignments.metadata["Database"], "seq/gst.nlib")
        # pGT875   pGT875
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 657)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 657)
        self.assertEqual(alignment.shape, (2, 657 + 0))
        self.assertEqual(alignment.sequences[0].id, "pGT875")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.6e-194)
        self.assertAlmostEqual(alignment.annotations["bit score"], 666.0)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[37, 694], [0, 657]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 694)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGAGTAACAAGTAG",
        )
        self.assertEqual(
            alignment[1],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGAGTAACAAGTAG",
        )
        # pGT875   RABGLTR
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 79.10)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 646)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 646)
        self.assertEqual(alignment.shape, (2, 646 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGLTR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 135)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.9e-118)
        self.assertAlmostEqual(alignment.annotations["bit score"], 414.4)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[33, 679], [0, 646]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 679)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "ATGCCCATGACGCTGGGTTACTGGGACGTCCGTGGGCTGGCTCTGCCAATCCGCATGCTCCTGGAATACACGGACACCAGCTATGAGGAAAAGAAATACACCATGGGGGATGCTCCCAACTATGACCAAAGCAAGTGGCTGAGTGAGAAGTTCACCCTGGGCCTGGACTTTCCCAATCTGCCCTACCTAATTGATGGGACTCACAAGCTCACGCAGAGCAACGCCATCCTGCGCTACCTGGCCCGCAAGCACGGCCTGTGTGGGGAGACGGAAGAGGAGAGGATTCGCGTGGACATTCTGGAGAATCAGCTGATGGACAACCGCTTCCAACTTGTAAACGTCTGCTACAGTCCCGACTTTGAGAAGCTCAAGCCCGAGTACCTGAAGGGGCTCCCTGAGAAGCTGCAGCTGTACTCGCAGTTCCTGGGAAGCCTCCCCTGGTTCGCAGGGGACAAGATCACCTTCGCCGATTTCCTTGTCTACGACGTTCTTGACCAGAACCGGATATTTGTGCCTGGGTGCCTGGACGCGTTCCCAAACCTGAAGGACTTTCATGTCCGCTTTGAGGGCCTGCCGAAGATCTCTGCCTACATGAAGTCCAGCCGCTTTATCCGAGTCCCTGTGTTTTTAAAGAAGGCCACGTGGA",
        )
        self.assertEqual(
            alignment[1],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGA",
        )
        # pGT875   BTGST
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 59.56)
        self.assertEqual(alignment.annotations["gap opens"], 21)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 413)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 413)
        self.assertEqual(alignment.shape, (2, 413 + 21))
        self.assertEqual(alignment.sequences[0].id, "BTGST")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 167)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.2e-07)
        self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[227, 376, 376, 383, 384, 401, 401, 461, 466, 472,
                              473, 486, 488, 501, 505, 535, 537, 543, 543, 655],
                             [175, 324, 325, 332, 332, 349, 352, 412, 412, 418,
                              418, 431, 431, 444, 444, 474, 474, 480, 482, 594]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 655)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "AGCTCCCCAAGTTCCAGGACGGAGACCTCACGCTGTACCAGTCCAATGCCATCCTGCGGCACCTGGGCCGCACCCTCGGGCTGTATGGGAAGGACCAGCAGGAGGCGGCCCTGGTGGACATGGTGAATGACGGTGTAGAGGACCTTCGC-TGCAAATACGTCTCCCTCATTTACA---CCAACTACGAGGCGGGCAAGGAGGACTATGTGAAGGCGCTGCCCCAGCACCTGAAGCCTTTCGAGACCCTGCTGTCCCAGAACAAGGGTGGCCAGGCCTTCATCGTGGGCGACCAGATCTCCTTTGCGGACTACAACCTGCT--GGACCTGCTTCGGATTCACCAGGTCCTGGCCCCCAGCTGTCTGGACTCCTTCCCCCTGCTCTCAGCCTACGTGGCCCGTCTCAACTCCCGGCCCAAGCTCAAGGCCTTCCTG",
        )
        self.assertEqual(
            alignment[1],
            "ATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCT-CATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCT-----ACTCTG-AGTTCCTGGGCAA--GAGGCCATGGTTT----GCAGGGGACAAGGTCACCTATGTGGATTTC--CTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATG",
        )
        # pGT875   RABGSTB
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['A', 'G', 'C', 'T', 'C', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'T',
              'C', 'C', 'A', 'G', 'G', 'A', 'C', 'G', 'G', 'A', 'G', 'A', 'C',
              'C', 'T', 'C', 'A', 'C', 'G', 'C', 'T', 'G', 'T', 'A', 'C', 'C',
              'A', 'G', 'T', 'C', 'C', 'A', 'A', 'T', 'G', 'C', 'C', 'A', 'T',
              'C', 'C', 'T', 'G', 'C', 'G', 'G', 'C', 'A', 'C', 'C', 'T', 'G',
              'G', 'G', 'C', 'C', 'G', 'C', 'A', 'C', 'C', 'C', 'T', 'C', 'G',
              'G', 'G', 'C', 'T', 'G', 'T', 'A', 'T', 'G', 'G', 'G', 'A', 'A',
              'G', 'G', 'A', 'C', 'C', 'A', 'G', 'C', 'A', 'G', 'G', 'A', 'G',
              'G', 'C', 'G', 'G', 'C', 'C', 'C', 'T', 'G', 'G', 'T', 'G', 'G',
              'A', 'C', 'A', 'T', 'G', 'G', 'T', 'G', 'A', 'A', 'T', 'G', 'A',
              'C', 'G', 'G', 'T', 'G', 'T', 'A', 'G', 'A', 'G', 'G', 'A', 'C',
              'C', 'T', 'T', 'C', 'G', 'C', '-', 'T', 'G', 'C', 'A', 'A', 'A',
              'T', 'A', 'C', 'G', 'T', 'C', 'T', 'C', 'C', 'C', 'T', 'C', 'A',
              'T', 'T', 'T', 'A', 'C', 'A', '-', '-', '-', 'C', 'C', 'A', 'A',
              'C', 'T', 'A', 'C', 'G', 'A', 'G', 'G', 'C', 'G', 'G', 'G', 'C',
              'A', 'A', 'G', 'G', 'A', 'G', 'G', 'A', 'C', 'T', 'A', 'T', 'G',
              'T', 'G', 'A', 'A', 'G', 'G', 'C', 'G', 'C', 'T', 'G', 'C', 'C',
              'C', 'C', 'A', 'G', 'C', 'A', 'C', 'C', 'T', 'G', 'A', 'A', 'G',
              'C', 'C', 'T', 'T', 'T', 'C', 'G', 'A', 'G', 'A', 'C', 'C', 'C',
              'T', 'G', 'C', 'T', 'G', 'T', 'C', 'C', 'C', 'A', 'G', 'A', 'A',
              'C', 'A', 'A', 'G', 'G', 'G', 'T', 'G', 'G', 'C', 'C', 'A', 'G',
              'G', 'C', 'C', 'T', 'T', 'C', 'A', 'T', 'C', 'G', 'T', 'G', 'G',
              'G', 'C', 'G', 'A', 'C', 'C', 'A', 'G', 'A', 'T', 'C', 'T', 'C',
              'C', 'T', 'T', 'T', 'G', 'C', 'G', 'G', 'A', 'C', 'T', 'A', 'C',
              'A', 'A', 'C', 'C', 'T', 'G', 'C', 'T', '-', '-', 'G', 'G', 'A',
              'C', 'C', 'T', 'G', 'C', 'T', 'T', 'C', 'G', 'G', 'A', 'T', 'T',
              'C', 'A', 'C', 'C', 'A', 'G', 'G', 'T', 'C', 'C', 'T', 'G', 'G',
              'C', 'C', 'C', 'C', 'C', 'A', 'G', 'C', 'T', 'G', 'T', 'C', 'T',
              'G', 'G', 'A', 'C', 'T', 'C', 'C', 'T', 'T', 'C', 'C', 'C', 'C',
              'C', 'T', 'G', 'C', 'T', 'C', 'T', 'C', 'A', 'G', 'C', 'C', 'T',
              'A', 'C', 'G', 'T', 'G', 'G', 'C', 'C', 'C', 'G', 'T', 'C', 'T',
              'C', 'A', 'A', 'C', 'T', 'C', 'C', 'C', 'G', 'G', 'C', 'C', 'C',
              'A', 'A', 'G', 'C', 'T', 'C', 'A', 'A', 'G', 'G', 'C', 'C', 'T',
              'T', 'C', 'C', 'T', 'G'],
             ['A', 'T', 'C', 'T', 'G', 'C', 'C', 'T', 'T', 'A', 'C', 'T', 'T',
              'G', 'A', 'T', 'C', 'G', 'A', 'T', 'G', 'G', 'A', 'T', 'C', 'A',
              'C', 'A', 'C', 'A', 'A', 'G', 'A', 'T', 'C', 'A', 'C', 'C', 'C',
              'A', 'G', 'A', 'G', 'C', 'A', 'A', 'T', 'G', 'C', 'C', 'A', 'T',
              'C', 'C', 'T', 'G', 'C', 'G', 'C', 'T', 'A', 'C', 'C', 'T', 'T',
              'G', 'C', 'C', 'C', 'G', 'A', 'A', 'A', 'G', 'C', 'A', 'C', 'C',
              'A', 'C', 'C', 'T', 'G', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'A',
              'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A', 'G',
              'A', 'G', 'G', 'A', 'T', 'C', 'C', 'G', 'T', 'G', 'C', 'A', 'G',
              'A', 'C', 'A', 'T', 'T', 'G', 'T', 'G', 'G', 'A', 'G', 'A', 'A',
              'C', 'C', 'A', 'G', 'G', 'T', 'C', 'A', 'T', 'G', 'G', 'A', 'C',
              'A', 'C', 'C', 'C', 'G', 'C', 'A', 'T', 'G', 'C', 'A', 'G', 'C',
              'T', '-', 'C', 'A', 'T', 'C', 'A', 'T', 'G', 'C', 'T', 'C', 'T',
              'G', 'T', 'T', 'A', 'C', 'A', 'A', 'C', 'C', 'C', 'T', 'G', 'A',
              'C', 'T', 'T', 'T', 'G', 'A', 'G', 'A', 'A', 'G', 'C', 'A', 'G',
              'A', 'A', 'G', 'C', 'C', 'A', 'G', 'A', 'G', 'T', 'T', 'C', 'T',
              'T', 'G', 'A', 'A', 'G', 'A', 'C', 'C', 'A', 'T', 'C', 'C', 'C',
              'T', 'G', 'A', 'G', 'A', 'A', 'A', 'A', 'T', 'G', 'A', 'A', 'G',
              'C', 'T', 'C', 'T', '-', '-', '-', '-', '-', 'A', 'C', 'T', 'C',
              'T', 'G', '-', 'A', 'G', 'T', 'T', 'C', 'C', 'T', 'G', 'G', 'G',
              'C', 'A', 'A', '-', '-', 'G', 'A', 'G', 'G', 'C', 'C', 'A', 'T',
              'G', 'G', 'T', 'T', 'T', '-', '-', '-', '-', 'G', 'C', 'A', 'G',
              'G', 'G', 'G', 'A', 'C', 'A', 'A', 'G', 'G', 'T', 'C', 'A', 'C',
              'C', 'T', 'A', 'T', 'G', 'T', 'G', 'G', 'A', 'T', 'T', 'T', 'C',
              '-', '-', 'C', 'T', 'T', 'G', 'C', 'T', 'T', 'A', 'T', 'G', 'A',
              'C', 'A', 'T', 'T', 'C', 'T', 'T', 'G', 'A', 'C', 'C', 'A', 'G',
              'T', 'A', 'C', 'C', 'G', 'T', 'A', 'T', 'G', 'T', 'T', 'T', 'G',
              'A', 'G', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'G', 'C', 'C', 'T',
              'G', 'G', 'A', 'C', 'G', 'C', 'C', 'T', 'T', 'C', 'C', 'C', 'A',
              'A', 'A', 'C', 'C', 'T', 'G', 'A', 'G', 'G', 'G', 'A', 'C', 'T',
              'T', 'C', 'C', 'T', 'G', 'G', 'C', 'C', 'C', 'G', 'C', 'T', 'T',
              'C', 'G', 'A', 'G', 'G', 'G', 'C', 'C', 'T', 'C', 'A', 'A', 'G',
              'A', 'A', 'G', 'A', 'T', 'C', 'T', 'C', 'T', 'G', 'C', 'C', 'T',
              'A', 'C', 'A', 'T', 'G']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 66.93)
        self.assertEqual(alignment.annotations["gap opens"], 8)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 127)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 127)
        self.assertEqual(alignment.shape, (2, 127 + 8))
        self.assertEqual(alignment.sequences[0].id, "RABGSTB")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 42)
        self.assertAlmostEqual(alignment.annotations["evalue"], 2.1e-07)
        self.assertAlmostEqual(alignment.annotations["bit score"], 45.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[156, 171, 173, 190, 190, 201, 202,
                              260, 261, 272, 272, 279, 279, 287],
                             [158, 173, 173, 190, 192, 203, 203,
                              261, 261, 272, 273, 280, 281, 289]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 287)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "GGGTATTGATGTTCCAGCAAGTGCCCATGGTTGA--GATTGATGGGATGAAGCTGGTGCAGACCAGAGCCATTTTCAACTACATTGCAGACAAGCACAACCTGTATGGGAAAGACATA-AAGGAGA-GAGCCCTG",
        )
        self.assertEqual(
            alignment[1],
            "GGGCCTGGACTTTCC--CAATCTGCCTTACTTGATCGATGGATCACA-CAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGAT-GGAGAGACAGAGGAGGAGAGGATCCGTG",
        )
        # pGT875   OCDHPR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'G', 'G', 'T', 'A', 'T', 'T', 'G', 'A', 'T', 'G', 'T', 'T',
              'C', 'C', 'A', 'G', 'C', 'A', 'A', 'G', 'T', 'G', 'C', 'C', 'C',
              'A', 'T', 'G', 'G', 'T', 'T', 'G', 'A', '-', '-', 'G', 'A', 'T',
              'T', 'G', 'A', 'T', 'G', 'G', 'G', 'A', 'T', 'G', 'A', 'A', 'G',
              'C', 'T', 'G', 'G', 'T', 'G', 'C', 'A', 'G', 'A', 'C', 'C', 'A',
              'G', 'A', 'G', 'C', 'C', 'A', 'T', 'T', 'T', 'T', 'C', 'A', 'A',
              'C', 'T', 'A', 'C', 'A', 'T', 'T', 'G', 'C', 'A', 'G', 'A', 'C',
              'A', 'A', 'G', 'C', 'A', 'C', 'A', 'A', 'C', 'C', 'T', 'G', 'T',
              'A', 'T', 'G', 'G', 'G', 'A', 'A', 'A', 'G', 'A', 'C', 'A', 'T',
              'A', '-', 'A', 'A', 'G', 'G', 'A', 'G', 'A', '-', 'G', 'A', 'G',
              'C', 'C', 'C', 'T', 'G'],
             ['G', 'G', 'G', 'C', 'C', 'T', 'G', 'G', 'A', 'C', 'T', 'T', 'T',
              'C', 'C', '-', '-', 'C', 'A', 'A', 'T', 'C', 'T', 'G', 'C', 'C',
              'T', 'T', 'A', 'C', 'T', 'T', 'G', 'A', 'T', 'C', 'G', 'A', 'T',
              'G', 'G', 'A', 'T', 'C', 'A', 'C', 'A', '-', 'C', 'A', 'A', 'G',
              'A', 'T', 'C', 'A', 'C', 'C', 'C', 'A', 'G', 'A', 'G', 'C', 'A',
              'A', 'T', 'G', 'C', 'C', 'A', 'T', 'C', 'C', 'T', 'G', 'C', 'G',
              'C', 'T', 'A', 'C', 'C', 'T', 'T', 'G', 'C', 'C', 'C', 'G', 'A',
              'A', 'A', 'G', 'C', 'A', 'C', 'C', 'A', 'C', 'C', 'T', 'G', 'G',
              'A', 'T', '-', 'G', 'G', 'A', 'G', 'A', 'G', 'A', 'C', 'A', 'G',
              'A', 'G', 'G', 'A', 'G', 'G', 'A', 'G', 'A', 'G', 'G', 'A', 'T',
              'C', 'C', 'G', 'T', 'G']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 91.30)
        self.assertEqual(alignment.annotations["gap opens"], 1)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 23)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 23)
        self.assertEqual(alignment.shape, (2, 23 + 1))
        self.assertEqual(alignment.sequences[0].id, "OCDHPR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.0092)
        self.assertAlmostEqual(alignment.annotations["bit score"], 30.1)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[2302, 2319, 2319, 2325],
                             [ 265,  282,  283,  289]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 2325)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "AGACAGAGGAGGAGAAG-TCTGTG")
        self.assertEqual(alignment[1], "AGACAGAGGAGGAGAGGATCCGTG")
        # pGT875   RABALP1A
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['A', 'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'A', 'G', '-', 'T', 'C', 'T', 'G', 'T', 'G'],
             ['A', 'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C', 'C', 'G', 'T', 'G']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 76.19)
        self.assertEqual(alignment.annotations["gap opens"], 4)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 42)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 42)
        self.assertEqual(alignment.shape, (2, 42 + 4))
        self.assertEqual(alignment.sequences[0].id, "RABALP1A")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 10)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.036)
        self.assertAlmostEqual(alignment.annotations["bit score"], 28.1)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[4973, 4987, 4987, 4990, 4990, 5002, 5003, 5016],
                             [ 240,  254,  256,  259,  260,  272,  272,  285]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 5016)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "GCTGGAGAGAGCCA--TGG-TGGAGGCTGCGATGGAGGAGAGGATC")
        self.assertEqual(alignment[1], "GCCCGAAAGCACCACCTGGATGGAGAGACAGA-GGAGGAGAGGATC")
        # pGT875   OCDHPR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'C', 'T', 'G', 'G', 'A', 'G', 'A', 'G', 'A', 'G', 'C', 'C',
              'A', '-', '-', 'T', 'G', 'G', '-', 'T', 'G', 'G', 'A', 'G', 'G',
              'C', 'T', 'G', 'C', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C'],
             ['G', 'C', 'C', 'C', 'G', 'A', 'A', 'A', 'G', 'C', 'A', 'C', 'C',
              'A', 'C', 'C', 'T', 'G', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'A',
              'G', 'A', 'C', 'A', 'G', 'A', '-', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 12)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 12)
        self.assertEqual(alignment.shape, (2, 12 + 0))
        self.assertEqual(alignment.sequences[0].id, "OCDHPR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.071)
        self.assertAlmostEqual(alignment.annotations["bit score"], 27.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1499, 1511], [316, 304]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1511)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCATGACCTGGT")
        self.assertEqual(alignment[1], "CCATGACCTGGT")
        # pGT875   RABALP1A
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T'],
             ['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 12)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 12)
        self.assertEqual(alignment.shape, (2, 12 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABALP1A")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.071)
        self.assertAlmostEqual(alignment.annotations["bit score"], 27.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1499, 1511], [316, 304]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1511)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCATGACCTGGT")
        self.assertEqual(alignment[1], "CCATGACCTGGT")
        # pGT875   RABGSTB
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T'],
             ['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 87.50)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 16)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 16)
        self.assertEqual(alignment.shape, (2, 16 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGSTB")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.14)
        self.assertAlmostEqual(alignment.annotations["bit score"], 26.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[490, 506], [160, 144]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 506)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCTGGTTGAACTTCTC")
        self.assertEqual(alignment[1], "CCAGCTTGAACTTCTC")
        # pGT875   RABGLTR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'T', 'G', 'G', 'T', 'T', 'G', 'A', 'A', 'C', 'T', 'T',
              'C', 'T', 'C'],
             ['C', 'C', 'A', 'G', 'C', 'T', 'T', 'G', 'A', 'A', 'C', 'T', 'T',
              'C', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 53.57)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 84)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 84)
        self.assertEqual(alignment.shape, (2, 84 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGLTR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 39)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.28)
        self.assertAlmostEqual(alignment.annotations["bit score"], 25.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1116, 1200], [242, 158]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1200)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "GCATGGCTGGGTGGGGCAGGATTAGTGTGGGGGGAGTTGGGTGCTCAGGCAGGGCTATGAGGGATCTTGTTCATTTCCGGGCCC",
        )
        self.assertEqual(
            alignment[1],
            "GCAAGGTAGCGCAGGATGGCATTGCTCTGGGTGATCTTGTGTGATCCATCGATCAAGTAAGGCAGATTGGGAAAGTCCAGGCCC",
        )
        # pGT875   pGT875
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'C', 'A', 'T', 'G', 'G', 'C', 'T', 'G', 'G', 'G', 'T', 'G',
              'G', 'G', 'G', 'C', 'A', 'G', 'G', 'A', 'T', 'T', 'A', 'G', 'T',
              'G', 'T', 'G', 'G', 'G', 'G', 'G', 'G', 'A', 'G', 'T', 'T', 'G',
              'G', 'G', 'T', 'G', 'C', 'T', 'C', 'A', 'G', 'G', 'C', 'A', 'G',
              'G', 'G', 'C', 'T', 'A', 'T', 'G', 'A', 'G', 'G', 'G', 'A', 'T',
              'C', 'T', 'T', 'G', 'T', 'T', 'C', 'A', 'T', 'T', 'T', 'C', 'C',
              'G', 'G', 'G', 'C', 'C', 'C'],
             ['G', 'C', 'A', 'A', 'G', 'G', 'T', 'A', 'G', 'C', 'G', 'C', 'A',
              'G', 'G', 'A', 'T', 'G', 'G', 'C', 'A', 'T', 'T', 'G', 'C', 'T',
              'C', 'T', 'G', 'G', 'G', 'T', 'G', 'A', 'T', 'C', 'T', 'T', 'G',
              'T', 'G', 'T', 'G', 'A', 'T', 'C', 'C', 'A', 'T', 'C', 'G', 'A',
              'T', 'C', 'A', 'A', 'G', 'T', 'A', 'A', 'G', 'G', 'C', 'A', 'G',
              'A', 'T', 'T', 'G', 'G', 'G', 'A', 'A', 'A', 'G', 'T', 'C', 'C',
              'A', 'G', 'G', 'C', 'C', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 10)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 10)
        self.assertEqual(alignment.shape, (2, 10 + 0))
        self.assertEqual(alignment.sequences[0].id, "pGT875")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.28)
        self.assertAlmostEqual(alignment.annotations["bit score"], 25.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[792, 802], [310, 300]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 802)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCTGGTTCTC")
        self.assertEqual(alignment[1], "CCTGGTTCTC")
        # pGT875   BTGST
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'T', 'G', 'G', 'T', 'T', 'C', 'T', 'C'],
             ['C', 'C', 'T', 'G', 'G', 'T', 'T', 'C', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 59.15)
        self.assertEqual(alignment.annotations["gap opens"], 3)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 71)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 71)
        self.assertEqual(alignment.shape, (2, 71 + 3))
        self.assertEqual(alignment.sequences[0].id, "BTGST")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 29)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.56)
        self.assertAlmostEqual(alignment.annotations["bit score"], 24.2)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[280, 304, 304, 312, 312, 351],
                             [378, 354, 353, 345, 343, 304]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 351)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "CTGCGGCACCTGGGCCGCACCCTC-GGGCTGTA--TGGGAAGGACCAGCAGGAGGCGGCCCTGGTGGACATGGT",
        )
        self.assertEqual(
            alignment[1],
            "CTCTGGCTTCTGCTTCTCAAAGTCAGGGTTGTAACAGAGCATGATGAGCTGCATGCGGGTGTCCATGACCTGGT",
        )
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'T', 'G', 'C', 'G', 'G', 'C', 'A', 'C', 'C', 'T', 'G', 'G',
              'G', 'C', 'C', 'G', 'C', 'A', 'C', 'C', 'C', 'T', 'C', '-', 'G',
              'G', 'G', 'C', 'T', 'G', 'T', 'A', '-', '-', 'T', 'G', 'G', 'G',
              'A', 'A', 'G', 'G', 'A', 'C', 'C', 'A', 'G', 'C', 'A', 'G', 'G',
              'A', 'G', 'G', 'C', 'G', 'G', 'C', 'C', 'C', 'T', 'G', 'G', 'T',
              'G', 'G', 'A', 'C', 'A', 'T', 'G', 'G', 'T'],
             ['C', 'T', 'C', 'T', 'G', 'G', 'C', 'T', 'T', 'C', 'T', 'G', 'C',
              'T', 'T', 'C', 'T', 'C', 'A', 'A', 'A', 'G', 'T', 'C', 'A', 'G',
              'G', 'G', 'T', 'T', 'G', 'T', 'A', 'A', 'C', 'A', 'G', 'A', 'G',
              'C', 'A', 'T', 'G', 'A', 'T', 'G', 'A', 'G', 'C', 'T', 'G', 'C',
              'A', 'T', 'G', 'C', 'G', 'G', 'G', 'T', 'G', 'T', 'C', 'C', 'A',
              'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']], dtype='U')
                # fmt: on
            )
        )
        with self.assertRaises(StopIteration):
            next(alignments)

    def test_m8CC(self):
        # Alignment file obtained by running
        # fasta36 -m 8CC seq/mgstm1.nt seq/gst.nlib
        # in the fasta36 source distribution
        path = "Fasta/nucleotide_m8CC.txt"
        alignments = Align.parse(path, "tabular")
        self.assertEqual(
            alignments.metadata["Command line"],
            "fasta36 -m 8CC seq/mgstm1.nt seq/gst.nlib",
        )
        self.assertEqual(alignments.metadata["Program"], "FASTA")
        self.assertEqual(alignments.metadata["Version"], "36.3.8h May, 2020")
        self.assertEqual(alignments.metadata["Database"], "seq/gst.nlib")
        # pGT875   pGT875
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 657)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 657)
        self.assertEqual(alignment.shape, (2, 657 + 0))
        self.assertEqual(alignment.sequences[0].id, "pGT875")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.6e-194)
        self.assertAlmostEqual(alignment.annotations["bit score"], 655.6)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[37, 694], [0, 657]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 694)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGAGTAACAAGTAG",
        )
        self.assertEqual(
            alignment[1],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGAGTAACAAGTAG",
        )
        # pGT875   RABGLTR
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 79.10)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 646)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 646)
        self.assertEqual(alignment.shape, (2, 646 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGLTR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 135)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.9e-118)
        self.assertAlmostEqual(alignment.annotations["bit score"], 408.0)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[33, 679], [0, 646]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 679)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "ATGCCCATGACGCTGGGTTACTGGGACGTCCGTGGGCTGGCTCTGCCAATCCGCATGCTCCTGGAATACACGGACACCAGCTATGAGGAAAAGAAATACACCATGGGGGATGCTCCCAACTATGACCAAAGCAAGTGGCTGAGTGAGAAGTTCACCCTGGGCCTGGACTTTCCCAATCTGCCCTACCTAATTGATGGGACTCACAAGCTCACGCAGAGCAACGCCATCCTGCGCTACCTGGCCCGCAAGCACGGCCTGTGTGGGGAGACGGAAGAGGAGAGGATTCGCGTGGACATTCTGGAGAATCAGCTGATGGACAACCGCTTCCAACTTGTAAACGTCTGCTACAGTCCCGACTTTGAGAAGCTCAAGCCCGAGTACCTGAAGGGGCTCCCTGAGAAGCTGCAGCTGTACTCGCAGTTCCTGGGAAGCCTCCCCTGGTTCGCAGGGGACAAGATCACCTTCGCCGATTTCCTTGTCTACGACGTTCTTGACCAGAACCGGATATTTGTGCCTGGGTGCCTGGACGCGTTCCCAAACCTGAAGGACTTTCATGTCCGCTTTGAGGGCCTGCCGAAGATCTCTGCCTACATGAAGTCCAGCCGCTTTATCCGAGTCCCTGTGTTTTTAAAGAAGGCCACGTGGA",
        )
        self.assertEqual(
            alignment[1],
            "ATGCCTATGATACTGGGATACTGGAACGTCCGCGGACTGACACACCCGATCCGCATGCTCCTGGAATACACAGACTCAAGCTATGATGAGAAGAGATACACCATGGGTGACGCTCCCGACTTTGACAGAAGCCAGTGGCTGAATGAGAAGTTCAAGCTGGGCCTGGACTTTCCCAATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCTCATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCTACTCTGAGTTCCTGGGCAAGAGGCCATGGTTTGCAGGGGACAAGGTCACCTATGTGGATTTCCTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATGAAGAGTAGCCGCTACATCGCAACACCTATATTTTCAAAGATGGCCCACTGGA",
        )
        # pGT875   BTGST
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 59.56)
        self.assertEqual(alignment.annotations["gap opens"], 21)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 413)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 413)
        self.assertEqual(alignment.shape, (2, 413 + 21))
        self.assertEqual(alignment.sequences[0].id, "BTGST")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 167)
        self.assertAlmostEqual(alignment.annotations["evalue"], 1.9e-07)
        self.assertAlmostEqual(alignment.annotations["bit score"], 45.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[227, 376, 376, 383, 384, 401, 401, 461, 466, 472,
                              473, 486, 488, 501, 505, 535, 537, 543, 543, 655],
                             [175, 324, 325, 332, 332, 349, 352, 412, 412, 418,
                              418, 431, 431, 444, 444, 474, 474, 480, 482, 594]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 655)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "AGCTCCCCAAGTTCCAGGACGGAGACCTCACGCTGTACCAGTCCAATGCCATCCTGCGGCACCTGGGCCGCACCCTCGGGCTGTATGGGAAGGACCAGCAGGAGGCGGCCCTGGTGGACATGGTGAATGACGGTGTAGAGGACCTTCGC-TGCAAATACGTCTCCCTCATTTACA---CCAACTACGAGGCGGGCAAGGAGGACTATGTGAAGGCGCTGCCCCAGCACCTGAAGCCTTTCGAGACCCTGCTGTCCCAGAACAAGGGTGGCCAGGCCTTCATCGTGGGCGACCAGATCTCCTTTGCGGACTACAACCTGCT--GGACCTGCTTCGGATTCACCAGGTCCTGGCCCCCAGCTGTCTGGACTCCTTCCCCCTGCTCTCAGCCTACGTGGCCCGTCTCAACTCCCGGCCCAAGCTCAAGGCCTTCCTG",
        )
        self.assertEqual(
            alignment[1],
            "ATCTGCCTTACTTGATCGATGGATCACACAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGATGGAGAGACAGAGGAGGAGAGGATCCGTGCAGACATTGTGGAGAACCAGGTCATGGACACCCGCATGCAGCT-CATCATGCTCTGTTACAACCCTGACTTTGAGAAGCAGAAGCCAGAGTTCTTGAAGACCATCCCTGAGAAAATGAAGCTCT-----ACTCTG-AGTTCCTGGGCAA--GAGGCCATGGTTT----GCAGGGGACAAGGTCACCTATGTGGATTTC--CTTGCTTATGACATTCTTGACCAGTACCGTATGTTTGAGCCCAAGTGCCTGGACGCCTTCCCAAACCTGAGGGACTTCCTGGCCCGCTTCGAGGGCCTCAAGAAGATCTCTGCCTACATG",
        )
        # pGT875   RABGSTB
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['A', 'G', 'C', 'T', 'C', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'T',
              'C', 'C', 'A', 'G', 'G', 'A', 'C', 'G', 'G', 'A', 'G', 'A', 'C',
              'C', 'T', 'C', 'A', 'C', 'G', 'C', 'T', 'G', 'T', 'A', 'C', 'C',
              'A', 'G', 'T', 'C', 'C', 'A', 'A', 'T', 'G', 'C', 'C', 'A', 'T',
              'C', 'C', 'T', 'G', 'C', 'G', 'G', 'C', 'A', 'C', 'C', 'T', 'G',
              'G', 'G', 'C', 'C', 'G', 'C', 'A', 'C', 'C', 'C', 'T', 'C', 'G',
              'G', 'G', 'C', 'T', 'G', 'T', 'A', 'T', 'G', 'G', 'G', 'A', 'A',
              'G', 'G', 'A', 'C', 'C', 'A', 'G', 'C', 'A', 'G', 'G', 'A', 'G',
              'G', 'C', 'G', 'G', 'C', 'C', 'C', 'T', 'G', 'G', 'T', 'G', 'G',
              'A', 'C', 'A', 'T', 'G', 'G', 'T', 'G', 'A', 'A', 'T', 'G', 'A',
              'C', 'G', 'G', 'T', 'G', 'T', 'A', 'G', 'A', 'G', 'G', 'A', 'C',
              'C', 'T', 'T', 'C', 'G', 'C', '-', 'T', 'G', 'C', 'A', 'A', 'A',
              'T', 'A', 'C', 'G', 'T', 'C', 'T', 'C', 'C', 'C', 'T', 'C', 'A',
              'T', 'T', 'T', 'A', 'C', 'A', '-', '-', '-', 'C', 'C', 'A', 'A',
              'C', 'T', 'A', 'C', 'G', 'A', 'G', 'G', 'C', 'G', 'G', 'G', 'C',
              'A', 'A', 'G', 'G', 'A', 'G', 'G', 'A', 'C', 'T', 'A', 'T', 'G',
              'T', 'G', 'A', 'A', 'G', 'G', 'C', 'G', 'C', 'T', 'G', 'C', 'C',
              'C', 'C', 'A', 'G', 'C', 'A', 'C', 'C', 'T', 'G', 'A', 'A', 'G',
              'C', 'C', 'T', 'T', 'T', 'C', 'G', 'A', 'G', 'A', 'C', 'C', 'C',
              'T', 'G', 'C', 'T', 'G', 'T', 'C', 'C', 'C', 'A', 'G', 'A', 'A',
              'C', 'A', 'A', 'G', 'G', 'G', 'T', 'G', 'G', 'C', 'C', 'A', 'G',
              'G', 'C', 'C', 'T', 'T', 'C', 'A', 'T', 'C', 'G', 'T', 'G', 'G',
              'G', 'C', 'G', 'A', 'C', 'C', 'A', 'G', 'A', 'T', 'C', 'T', 'C',
              'C', 'T', 'T', 'T', 'G', 'C', 'G', 'G', 'A', 'C', 'T', 'A', 'C',
              'A', 'A', 'C', 'C', 'T', 'G', 'C', 'T', '-', '-', 'G', 'G', 'A',
              'C', 'C', 'T', 'G', 'C', 'T', 'T', 'C', 'G', 'G', 'A', 'T', 'T',
              'C', 'A', 'C', 'C', 'A', 'G', 'G', 'T', 'C', 'C', 'T', 'G', 'G',
              'C', 'C', 'C', 'C', 'C', 'A', 'G', 'C', 'T', 'G', 'T', 'C', 'T',
              'G', 'G', 'A', 'C', 'T', 'C', 'C', 'T', 'T', 'C', 'C', 'C', 'C',
              'C', 'T', 'G', 'C', 'T', 'C', 'T', 'C', 'A', 'G', 'C', 'C', 'T',
              'A', 'C', 'G', 'T', 'G', 'G', 'C', 'C', 'C', 'G', 'T', 'C', 'T',
              'C', 'A', 'A', 'C', 'T', 'C', 'C', 'C', 'G', 'G', 'C', 'C', 'C',
              'A', 'A', 'G', 'C', 'T', 'C', 'A', 'A', 'G', 'G', 'C', 'C', 'T',
              'T', 'C', 'C', 'T', 'G'],
             ['A', 'T', 'C', 'T', 'G', 'C', 'C', 'T', 'T', 'A', 'C', 'T', 'T',
              'G', 'A', 'T', 'C', 'G', 'A', 'T', 'G', 'G', 'A', 'T', 'C', 'A',
              'C', 'A', 'C', 'A', 'A', 'G', 'A', 'T', 'C', 'A', 'C', 'C', 'C',
              'A', 'G', 'A', 'G', 'C', 'A', 'A', 'T', 'G', 'C', 'C', 'A', 'T',
              'C', 'C', 'T', 'G', 'C', 'G', 'C', 'T', 'A', 'C', 'C', 'T', 'T',
              'G', 'C', 'C', 'C', 'G', 'A', 'A', 'A', 'G', 'C', 'A', 'C', 'C',
              'A', 'C', 'C', 'T', 'G', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'A',
              'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A', 'G',
              'A', 'G', 'G', 'A', 'T', 'C', 'C', 'G', 'T', 'G', 'C', 'A', 'G',
              'A', 'C', 'A', 'T', 'T', 'G', 'T', 'G', 'G', 'A', 'G', 'A', 'A',
              'C', 'C', 'A', 'G', 'G', 'T', 'C', 'A', 'T', 'G', 'G', 'A', 'C',
              'A', 'C', 'C', 'C', 'G', 'C', 'A', 'T', 'G', 'C', 'A', 'G', 'C',
              'T', '-', 'C', 'A', 'T', 'C', 'A', 'T', 'G', 'C', 'T', 'C', 'T',
              'G', 'T', 'T', 'A', 'C', 'A', 'A', 'C', 'C', 'C', 'T', 'G', 'A',
              'C', 'T', 'T', 'T', 'G', 'A', 'G', 'A', 'A', 'G', 'C', 'A', 'G',
              'A', 'A', 'G', 'C', 'C', 'A', 'G', 'A', 'G', 'T', 'T', 'C', 'T',
              'T', 'G', 'A', 'A', 'G', 'A', 'C', 'C', 'A', 'T', 'C', 'C', 'C',
              'T', 'G', 'A', 'G', 'A', 'A', 'A', 'A', 'T', 'G', 'A', 'A', 'G',
              'C', 'T', 'C', 'T', '-', '-', '-', '-', '-', 'A', 'C', 'T', 'C',
              'T', 'G', '-', 'A', 'G', 'T', 'T', 'C', 'C', 'T', 'G', 'G', 'G',
              'C', 'A', 'A', '-', '-', 'G', 'A', 'G', 'G', 'C', 'C', 'A', 'T',
              'G', 'G', 'T', 'T', 'T', '-', '-', '-', '-', 'G', 'C', 'A', 'G',
              'G', 'G', 'G', 'A', 'C', 'A', 'A', 'G', 'G', 'T', 'C', 'A', 'C',
              'C', 'T', 'A', 'T', 'G', 'T', 'G', 'G', 'A', 'T', 'T', 'T', 'C',
              '-', '-', 'C', 'T', 'T', 'G', 'C', 'T', 'T', 'A', 'T', 'G', 'A',
              'C', 'A', 'T', 'T', 'C', 'T', 'T', 'G', 'A', 'C', 'C', 'A', 'G',
              'T', 'A', 'C', 'C', 'G', 'T', 'A', 'T', 'G', 'T', 'T', 'T', 'G',
              'A', 'G', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'G', 'C', 'C', 'T',
              'G', 'G', 'A', 'C', 'G', 'C', 'C', 'T', 'T', 'C', 'C', 'C', 'A',
              'A', 'A', 'C', 'C', 'T', 'G', 'A', 'G', 'G', 'G', 'A', 'C', 'T',
              'T', 'C', 'C', 'T', 'G', 'G', 'C', 'C', 'C', 'G', 'C', 'T', 'T',
              'C', 'G', 'A', 'G', 'G', 'G', 'C', 'C', 'T', 'C', 'A', 'A', 'G',
              'A', 'A', 'G', 'A', 'T', 'C', 'T', 'C', 'T', 'G', 'C', 'C', 'T',
              'A', 'C', 'A', 'T', 'G']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 66.93)
        self.assertEqual(alignment.annotations["gap opens"], 8)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 127)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 127)
        self.assertEqual(alignment.shape, (2, 127 + 8))
        self.assertEqual(alignment.sequences[0].id, "RABGSTB")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 42)
        self.assertAlmostEqual(alignment.annotations["evalue"], 3.2e-07)
        self.assertAlmostEqual(alignment.annotations["bit score"], 45.0)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[156, 171, 173, 190, 190, 201, 202,
                              260, 261, 272, 272, 279, 279, 287],
                             [158, 173, 173, 190, 192, 203, 203,
                              261, 261, 272, 273, 280, 281, 289]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 287)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "GGGTATTGATGTTCCAGCAAGTGCCCATGGTTGA--GATTGATGGGATGAAGCTGGTGCAGACCAGAGCCATTTTCAACTACATTGCAGACAAGCACAACCTGTATGGGAAAGACATA-AAGGAGA-GAGCCCTG",
        )
        self.assertEqual(
            alignment[1],
            "GGGCCTGGACTTTCC--CAATCTGCCTTACTTGATCGATGGATCACA-CAAGATCACCCAGAGCAATGCCATCCTGCGCTACCTTGCCCGAAAGCACCACCTGGAT-GGAGAGACAGAGGAGGAGAGGATCCGTG",
        )
        # pGT875   OCDHPR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'G', 'G', 'T', 'A', 'T', 'T', 'G', 'A', 'T', 'G', 'T', 'T',
              'C', 'C', 'A', 'G', 'C', 'A', 'A', 'G', 'T', 'G', 'C', 'C', 'C',
              'A', 'T', 'G', 'G', 'T', 'T', 'G', 'A', '-', '-', 'G', 'A', 'T',
              'T', 'G', 'A', 'T', 'G', 'G', 'G', 'A', 'T', 'G', 'A', 'A', 'G',
              'C', 'T', 'G', 'G', 'T', 'G', 'C', 'A', 'G', 'A', 'C', 'C', 'A',
              'G', 'A', 'G', 'C', 'C', 'A', 'T', 'T', 'T', 'T', 'C', 'A', 'A',
              'C', 'T', 'A', 'C', 'A', 'T', 'T', 'G', 'C', 'A', 'G', 'A', 'C',
              'A', 'A', 'G', 'C', 'A', 'C', 'A', 'A', 'C', 'C', 'T', 'G', 'T',
              'A', 'T', 'G', 'G', 'G', 'A', 'A', 'A', 'G', 'A', 'C', 'A', 'T',
              'A', '-', 'A', 'A', 'G', 'G', 'A', 'G', 'A', '-', 'G', 'A', 'G',
              'C', 'C', 'C', 'T', 'G'],
             ['G', 'G', 'G', 'C', 'C', 'T', 'G', 'G', 'A', 'C', 'T', 'T', 'T',
              'C', 'C', '-', '-', 'C', 'A', 'A', 'T', 'C', 'T', 'G', 'C', 'C',
              'T', 'T', 'A', 'C', 'T', 'T', 'G', 'A', 'T', 'C', 'G', 'A', 'T',
              'G', 'G', 'A', 'T', 'C', 'A', 'C', 'A', '-', 'C', 'A', 'A', 'G',
              'A', 'T', 'C', 'A', 'C', 'C', 'C', 'A', 'G', 'A', 'G', 'C', 'A',
              'A', 'T', 'G', 'C', 'C', 'A', 'T', 'C', 'C', 'T', 'G', 'C', 'G',
              'C', 'T', 'A', 'C', 'C', 'T', 'T', 'G', 'C', 'C', 'C', 'G', 'A',
              'A', 'A', 'G', 'C', 'A', 'C', 'C', 'A', 'C', 'C', 'T', 'G', 'G',
              'A', 'T', '-', 'G', 'G', 'A', 'G', 'A', 'G', 'A', 'C', 'A', 'G',
              'A', 'G', 'G', 'A', 'G', 'G', 'A', 'G', 'A', 'G', 'G', 'A', 'T',
              'C', 'C', 'G', 'T', 'G']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 91.30)
        self.assertEqual(alignment.annotations["gap opens"], 1)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 23)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 23)
        self.assertEqual(alignment.shape, (2, 23 + 1))
        self.assertEqual(alignment.sequences[0].id, "OCDHPR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.012)
        self.assertAlmostEqual(alignment.annotations["bit score"], 29.7)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[2302, 2319, 2319, 2325],
                              [265,  282,  283,  289]]),
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 2325)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "AGACAGAGGAGGAGAAG-TCTGTG")
        self.assertEqual(alignment[1], "AGACAGAGGAGGAGAGGATCCGTG")
        # pGT875   RABALP1A
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['A', 'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'A', 'G', '-', 'T', 'C', 'T', 'G', 'T', 'G'],
             ['A', 'G', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C', 'C', 'G', 'T', 'G']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 76.19)
        self.assertEqual(alignment.annotations["gap opens"], 4)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 42)
        self.assertEqual(sum(end - start for start, end in aligned[1]), 42)
        self.assertEqual(alignment.shape, (2, 42 + 4))
        self.assertEqual(alignment.sequences[0].id, "RABALP1A")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 10)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.046)
        self.assertAlmostEqual(alignment.annotations["bit score"], 27.8)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[4973, 4987, 4987, 4990, 4990, 5002, 5003, 5016],
                             [ 240,  254,  256,  259,  260,  272,  272,  285]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 5016)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "GCTGGAGAGAGCCA--TGG-TGGAGGCTGCGATGGAGGAGAGGATC")
        self.assertEqual(alignment[1], "GCCCGAAAGCACCACCTGGATGGAGAGACAGA-GGAGGAGAGGATC")
        # pGT875   OCDHPR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'C', 'T', 'G', 'G', 'A', 'G', 'A', 'G', 'A', 'G', 'C', 'C',
              'A', '-', '-', 'T', 'G', 'G', '-', 'T', 'G', 'G', 'A', 'G', 'G',
              'C', 'T', 'G', 'C', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C'],
             ['G', 'C', 'C', 'C', 'G', 'A', 'A', 'A', 'G', 'C', 'A', 'C', 'C',
              'A', 'C', 'C', 'T', 'G', 'G', 'A', 'T', 'G', 'G', 'A', 'G', 'A',
              'G', 'A', 'C', 'A', 'G', 'A', '-', 'G', 'G', 'A', 'G', 'G', 'A',
              'G', 'A', 'G', 'G', 'A', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 12)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 12)
        self.assertEqual(alignment.shape, (2, 12 + 0))
        self.assertEqual(alignment.sequences[0].id, "OCDHPR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.09)
        self.assertAlmostEqual(alignment.annotations["bit score"], 26.8)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1499, 1511], [316, 304]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1511)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCATGACCTGGT")
        self.assertEqual(alignment[1], "CCATGACCTGGT")
        # pGT875   RABALP1A
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T'],
             ['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 12)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 12)
        self.assertEqual(alignment.shape, (2, 12 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABALP1A")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.09)
        self.assertAlmostEqual(alignment.annotations["bit score"], 26.8)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1499, 1511], [316, 304]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1511)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCATGACCTGGT")
        self.assertEqual(alignment[1], "CCATGACCTGGT")
        # pGT875   RABGSTB
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T'],
             ['C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']],
            dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 87.50)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 16)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 16)
        self.assertEqual(alignment.shape, (2, 16 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGSTB")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 2)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.18)
        self.assertAlmostEqual(alignment.annotations["bit score"], 25.8)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[490, 506], [160, 144]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 506)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCTGGTTGAACTTCTC")
        self.assertEqual(alignment[1], "CCAGCTTGAACTTCTC")
        # pGT875   RABGLTR
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'T', 'G', 'G', 'T', 'T', 'G', 'A', 'A', 'C', 'T', 'T',
              'C', 'T', 'C'],
             ['C', 'C', 'A', 'G', 'C', 'T', 'T', 'G', 'A', 'A', 'C', 'T', 'T',
              'C', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 53.57)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 84)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 84)
        self.assertEqual(alignment.shape, (2, 84 + 0))
        self.assertEqual(alignment.sequences[0].id, "RABGLTR")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 39)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.35)
        self.assertAlmostEqual(alignment.annotations["bit score"], 24.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[1116, 1200], [242, 158]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 1200)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "GCATGGCTGGGTGGGGCAGGATTAGTGTGGGGGGAGTTGGGTGCTCAGGCAGGGCTATGAGGGATCTTGTTCATTTCCGGGCCC",
        )
        self.assertEqual(
            alignment[1],
            "GCAAGGTAGCGCAGGATGGCATTGCTCTGGGTGATCTTGTGTGATCCATCGATCAAGTAAGGCAGATTGGGAAAGTCCAGGCCC",
        )
        # pGT875   pGT875
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['G', 'C', 'A', 'T', 'G', 'G', 'C', 'T', 'G', 'G', 'G', 'T', 'G',
              'G', 'G', 'G', 'C', 'A', 'G', 'G', 'A', 'T', 'T', 'A', 'G', 'T',
              'G', 'T', 'G', 'G', 'G', 'G', 'G', 'G', 'A', 'G', 'T', 'T', 'G',
              'G', 'G', 'T', 'G', 'C', 'T', 'C', 'A', 'G', 'G', 'C', 'A', 'G',
              'G', 'G', 'C', 'T', 'A', 'T', 'G', 'A', 'G', 'G', 'G', 'A', 'T',
              'C', 'T', 'T', 'G', 'T', 'T', 'C', 'A', 'T', 'T', 'T', 'C', 'C',
              'G', 'G', 'G', 'C', 'C', 'C'],
             ['G', 'C', 'A', 'A', 'G', 'G', 'T', 'A', 'G', 'C', 'G', 'C', 'A',
              'G', 'G', 'A', 'T', 'G', 'G', 'C', 'A', 'T', 'T', 'G', 'C', 'T',
              'C', 'T', 'G', 'G', 'G', 'T', 'G', 'A', 'T', 'C', 'T', 'T', 'G',
              'T', 'G', 'T', 'G', 'A', 'T', 'C', 'C', 'A', 'T', 'C', 'G', 'A',
              'T', 'C', 'A', 'A', 'G', 'T', 'A', 'A', 'G', 'G', 'C', 'A', 'G',
              'A', 'T', 'T', 'G', 'G', 'G', 'A', 'A', 'A', 'G', 'T', 'C', 'C',
              'A', 'G', 'G', 'C', 'C', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
        self.assertEqual(alignment.annotations["gap opens"], 0)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 10)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 10)
        self.assertEqual(alignment.shape, (2, 10 + 0))
        self.assertEqual(alignment.sequences[0].id, "pGT875")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 0)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.35)
        self.assertAlmostEqual(alignment.annotations["bit score"], 24.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                numpy.array([[792, 802], [310, 300]]),
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 802)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(alignment[0], "CCTGGTTCTC")
        self.assertEqual(alignment[1], "CCTGGTTCTC")
        # pGT875   BTGST
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'C', 'T', 'G', 'G', 'T', 'T', 'C', 'T', 'C'],
             ['C', 'C', 'T', 'G', 'G', 'T', 'T', 'C', 'T', 'C']], dtype='U')
                # fmt: on
            )
        )
        alignment = next(alignments)
        self.assertEqual(len(alignment), 2)
        self.assertAlmostEqual(alignment.annotations["% identity"], 59.15)
        self.assertEqual(alignment.annotations["gap opens"], 3)
        aligned = alignment.aligned
        self.assertEqual(sum(end - start for start, end in aligned[0]), 71)
        self.assertEqual(sum(start - end for start, end in aligned[1]), 71)
        self.assertEqual(alignment.shape, (2, 71 + 3))
        self.assertEqual(alignment.sequences[0].id, "BTGST")
        self.assertEqual(alignment.sequences[1].id, "pGT875")
        self.assertEqual(alignment.annotations["mismatches"], 29)
        self.assertAlmostEqual(alignment.annotations["evalue"], 0.68)
        self.assertAlmostEqual(alignment.annotations["bit score"], 23.9)
        self.assertTrue(
            numpy.array_equal(
                alignment.coordinates,
                # fmt: off
# flake8: noqa
                numpy.array([[280, 304, 304, 312, 312, 351],
                             [378, 354, 353, 345, 343, 304]])
                # fmt: on
            )
        )
        query = self.query
        target = self.targets[alignment.sequences[0].id]
        self.assertEqual(len(alignment.sequences[0].seq), 351)
        self.assertEqual(len(alignment.sequences[1].seq), len(query))
        alignment.sequences[0].seq = target
        alignment.sequences[1].seq = query
        self.assertEqual(
            alignment[0],
            "CTGCGGCACCTGGGCCGCACCCTC-GGGCTGTA--TGGGAAGGACCAGCAGGAGGCGGCCCTGGTGGACATGGT",
        )
        self.assertEqual(
            alignment[1],
            "CTCTGGCTTCTGCTTCTCAAAGTCAGGGTTGTAACAGAGCATGATGAGCTGCATGCGGGTGTCCATGACCTGGT",
        )
        self.assertTrue(
            numpy.array_equal(
                numpy.array(alignment, "U"),
                # fmt: off
# flake8: noqa
numpy.array([['C', 'T', 'G', 'C', 'G', 'G', 'C', 'A', 'C', 'C', 'T', 'G', 'G',
              'G', 'C', 'C', 'G', 'C', 'A', 'C', 'C', 'C', 'T', 'C', '-', 'G',
              'G', 'G', 'C', 'T', 'G', 'T', 'A', '-', '-', 'T', 'G', 'G', 'G',
              'A', 'A', 'G', 'G', 'A', 'C', 'C', 'A', 'G', 'C', 'A', 'G', 'G',
              'A', 'G', 'G', 'C', 'G', 'G', 'C', 'C', 'C', 'T', 'G', 'G', 'T',
              'G', 'G', 'A', 'C', 'A', 'T', 'G', 'G', 'T'],
             ['C', 'T', 'C', 'T', 'G', 'G', 'C', 'T', 'T', 'C', 'T', 'G', 'C',
              'T', 'T', 'C', 'T', 'C', 'A', 'A', 'A', 'G', 'T', 'C', 'A', 'G',
              'G', 'G', 'T', 'T', 'G', 'T', 'A', 'A', 'C', 'A', 'G', 'A', 'G',
              'C', 'A', 'T', 'G', 'A', 'T', 'G', 'A', 'G', 'C', 'T', 'G', 'C',
              'A', 'T', 'G', 'C', 'G', 'G', 'G', 'T', 'G', 'T', 'C', 'C', 'A',
              'T', 'G', 'A', 'C', 'C', 'T', 'G', 'G', 'T']], dtype='U')
                # fmt: on
            )
        )
        with self.assertRaises(StopIteration):
            next(alignments)


class TestFastaBasic(unittest.TestCase):
    def test_empty(self):
        import io

        stream = io.StringIO()
        with self.assertRaisesRegex(ValueError, "Empty file."):
            Align.parse(stream, "tabular")


class TestBlast(unittest.TestCase):
    def test_2226_tblastn_001(self):
        path = "Blast/tab_2226_tblastn_001.txt"
        with open(path) as stream:
            with self.assertRaisesRegex(ValueError, "Missing header."):
                Align.parse(stream, "tabular")

    def test_2226_tblastn_002(self):
        path = "Blast/tab_2226_tblastn_002.txt"
        with open(path) as stream:
            with self.assertRaisesRegex(ValueError, "Empty file."):
                Align.parse(stream, "tabular")

    def test_2226_tblastn_003(self):
        path = "Blast/tab_2226_tblastn_003.txt"
        with open(path) as stream:
            with self.assertRaisesRegex(ValueError, "Missing header."):
                Align.parse(stream, "tabular")

    def test_2226_tblastn_004(self):
        path = "Blast/tab_2226_tblastn_004.txt"
        with open(path) as stream:
            with self.assertRaisesRegex(ValueError, "Missing header."):
                Align.parse(stream, "tabular")

    def test_2226_tblastn_005(self):
        path = "Blast/tab_2226_tblastn_005.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["Database"], "db/minirefseq_mrna")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|145479850|ref|XM_001425911.1|")
            self.assertEqual(alignment.query.annotations["start"], 30)
            self.assertEqual(alignment.query.annotations["end"], 73)
            self.assertEqual(alignment.target.annotations["start"], 1743)
            self.assertEqual(alignment.target.annotations["end"], 1872)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.88)
            self.assertEqual(alignment.annotations["alignment length"], 43)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|72012412|ref|XM_777959.1|")
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|115975252|ref|XM_001180111.1|")
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 94)
            self.assertEqual(alignment.target.annotations["end"], 388)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 199)
            self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 4)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 29)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 541)
            self.assertEqual(alignment.target.annotations["end"], 754)
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 32.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 29.58)
            self.assertEqual(alignment.annotations["alignment length"], 71)
            self.assertEqual(alignment.annotations["mismatches"], 46)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 77)
            self.assertEqual(alignment.target.annotations["end"], 371)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 803)
            self.assertEqual(alignment.target.annotations["end"], 1103)
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 160)
            self.assertEqual(alignment.target.annotations["end"], 454)
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 865)
            self.assertEqual(alignment.target.annotations["end"], 1165)
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 172)
            self.assertEqual(alignment.target.annotations["end"], 466)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 898)
            self.assertEqual(alignment.target.annotations["end"], 1198)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 63)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 11)
            self.assertEqual(alignment.query.annotations["end"], 54)
            self.assertEqual(alignment.target.annotations["start"], 3180)
            self.assertEqual(alignment.target.annotations["end"], 3336)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 19.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.77)
            self.assertEqual(alignment.annotations["alignment length"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2226_tblastn_007(self):
        path = "Blast/tab_2226_tblastn_007.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["Database"], "db/minirefseq_mrna")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|145479850|ref|XM_001425911.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["start"], 30)
            self.assertEqual(alignment.query.annotations["end"], 73)
            self.assertEqual(alignment.target.annotations["start"], 1743)
            self.assertEqual(alignment.target.annotations["end"], 1872)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.88)
            self.assertEqual(alignment.annotations["alignment length"], 43)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|72012412|ref|XM_777959.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|115975252|ref|XM_001180111.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2226_tblastn_008(self):
        path = "Blast/tab_2226_tblastn_008.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["Database"], "db/minirefseq_mrna")

            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 94)
            self.assertEqual(alignment.target.annotations["end"], 388)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 199)
            self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 4)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 29)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 541)
            self.assertEqual(alignment.target.annotations["end"], 754)
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 32.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 29.58)
            self.assertEqual(alignment.annotations["alignment length"], 71)
            self.assertEqual(alignment.annotations["mismatches"], 46)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 77)
            self.assertEqual(alignment.target.annotations["end"], 371)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 803)
            self.assertEqual(alignment.target.annotations["end"], 1103)
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 160)
            self.assertEqual(alignment.target.annotations["end"], 454)
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 865)
            self.assertEqual(alignment.target.annotations["end"], 1165)
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 172)
            self.assertEqual(alignment.target.annotations["end"], 466)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 898)
            self.assertEqual(alignment.target.annotations["end"], 1198)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 63)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 11)
            self.assertEqual(alignment.query.annotations["end"], 54)
            self.assertEqual(alignment.target.annotations["start"], 3180)
            self.assertEqual(alignment.target.annotations["end"], 3336)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 19.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.77)
            self.assertEqual(alignment.annotations["alignment length"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2226_tblastn_009(self):
        path = "Blast/tab_2226_tblastn_009.txt"
        with open(path) as stream:
            with self.assertRaisesRegex(ValueError, "Missing header."):
                Align.parse(stream, "tabular")

    def test_2226_tblastn_010(self):
        path = "Blast/tab_2226_tblastn_010.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["Database"], "db/minirefseq_mrna")

            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|145479850|ref|XM_001425911.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.7)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|72012412|ref|XM_777959.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|115975252|ref|XM_001180111.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 199)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 32.7)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 19.6)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2226_tblastn_011(self):
        path = "Blast/tab_2226_tblastn_011.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["Database"], "db/minirefseq_mrna")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(
                alignment.query.annotations["acc."], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(len(alignment.query.seq), 102)
            self.assertEqual(alignment.target.id, "gi|145479850|ref|XM_001425911.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|145479850|ref|XM_001425911.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|145479850|ref|XM_001425911.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|145479850|ref|XM_001425911.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 4632)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    numpy.array([[0, 43], [30, 73]]),
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 1743)
            self.assertEqual(alignment.target.annotations["end"], 1872)
            self.assertEqual(
                alignment.target.seq, "PKTATGTKKGTIIGLLSIHTILFILTSHALSLEVKEQT*KDID"
            )
            self.assertEqual(
                alignment.query.seq[30:73],
                "PDSNIETKEGTYVGLADTHTIEVTVDNEPVSLDITEESTSDLD",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.7)
            self.assertAlmostEqual(alignment.score, 78)
            self.assertEqual(alignment.shape, (2, 43))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.88)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.47)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/1")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(
                alignment.query.annotations["acc."], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(len(alignment.query.seq), 102)
            self.assertEqual(alignment.target.id, "gi|72012412|ref|XM_777959.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|72012412|ref|XM_777959.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|72012412|ref|XM_777959.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"], "gi|72012412|ref|XM_777959.1|"
            )
            self.assertEqual(alignment.target.annotations["length"], 1593)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 35, 43, 59],
                                 [43, 78, 78, 94]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertEqual(
                alignment.target.seq,
                "GLVPDHTLILPVGHYQSMLDLTEEVQTELDQFKSALRKYYLSKGKTCVIYERNFRTQHL",
            )
            self.assertEqual(
                alignment.query.seq[43:94],
                "GLADTHTIEVTVDNEPVSLDITEESTSDLDKFNSGDKVTITYEKNDEGQLL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 59))
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            self.assertEqual(alignment.annotations["gaps"], 8)
            self.assertAlmostEqual(alignment.annotations["% positives"], 49.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/1")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(
                alignment.query.description,
                "membrane bound lipoprotein [Bacillus subtilis subsp. subtilis str. 168]",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(
                alignment.query.annotations["acc."], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|16080617|ref|NP_391444.1|"
            )
            self.assertEqual(len(alignment.query.seq), 102)
            self.assertEqual(alignment.target.id, "gi|115975252|ref|XM_001180111.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|115975252|ref|XM_001180111.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|115975252|ref|XM_001180111.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|115975252|ref|XM_001180111.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1593)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 35, 43, 59],
                                 [43, 78, 78, 94]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertEqual(
                alignment.target.seq,
                "GLVPDHTLILPVGHYQSMLDLTEEVQTELDQFKSALRKYYLSKGKTCVIYERNFRTQHL",
            )
            self.assertEqual(
                alignment.query.seq[43:94],
                "GLADTHTIEVTVDNEPVSLDITEESTSDLDKFNSGDKVTITYEKNDEGQLL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 59))
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            self.assertEqual(alignment.annotations["gaps"], 8)
            self.assertAlmostEqual(alignment.annotations["% positives"], 49.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/1")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350596019|ref|XM_003360601.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|350596019|ref|XM_003360601.2|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|350596019|ref|XM_003360601.2|",
            )
            self.assertEqual(alignment.target.annotations["length"], 772)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates, numpy.array([[0, 98], [0, 98]])
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 94)
            self.assertEqual(alignment.target.annotations["end"], 388)
            self.assertEqual(
                alignment.target.seq,
                "KRIREGYLVKKGSMFNTWKPMWVILLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVFKITTTKQQDHFFQAAFLEERDGWVRDIKKAIK",
            )
            self.assertEqual(
                alignment.query.seq[0:98],
                "KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 199)
            self.assertAlmostEqual(alignment.score, 506)
            self.assertEqual(alignment.shape, (2, 98))
            self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
            self.assertEqual(alignment.annotations["identical"], 94)
            self.assertEqual(alignment.annotations["mismatches"], 4)
            self.assertEqual(alignment.annotations["positives"], 96)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 97.96)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350596019|ref|XM_003360601.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|350596019|ref|XM_003360601.2|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|350596019|ref|XM_003360601.2|",
            )
            self.assertEqual(alignment.target.annotations["length"], 772)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 25, 26, 39, 42, 71],
                                 [29, 54, 54, 67, 67, 96]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 541)
            self.assertEqual(alignment.target.annotations["end"], 754)
            self.assertEqual(
                alignment.target.seq,
                "LHYYDPAGGEDPLGAIHLRGCVVTSVESNTDGKNGFLWERAXXITADEVHYFLQAANPKERTEWIKAIQVA",
            )
            self.assertEqual(
                alignment.query.seq[29:96],
                "IEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 32.7)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 71))
            self.assertAlmostEqual(alignment.annotations["% identity"], 29.58)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 46)
            self.assertEqual(alignment.annotations["positives"], 33)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            self.assertEqual(alignment.annotations["gaps"], 4)
            self.assertAlmostEqual(alignment.annotations["% positives"], 46.48)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|301779869|ref|XM_002925302.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|301779869|ref|XM_002925302.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|301779869|ref|XM_002925302.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1144)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    numpy.array([[0, 98], [0, 98]]),
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 77)
            self.assertEqual(alignment.target.annotations["end"], 371)
            self.assertEqual(
                alignment.target.seq,
                "KRIREGYLVKRGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVFKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertEqual(
                alignment.query.seq[0:98],
                "KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.score, 515)
            self.assertEqual(alignment.shape, (2, 98))
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["identical"], 96)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["positives"], 97)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 98.98)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/3")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|301779869|ref|XM_002925302.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|301779869|ref|XM_002925302.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|301779869|ref|XM_002925302.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1144)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[0, 27, 29, 54, 58, 100],
                                 [2, 29, 29, 54, 54,  96]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 803)
            self.assertEqual(alignment.target.annotations["end"], 1103)
            self.assertEqual(
                alignment.target.seq,
                "IKQGCLLKQGHRRKNWKVRKFILREDPAYLHYYDPAGGEDPLGAIHLRGCVVTSVESNPDVRKSEEENLFEIITADEVHYFLQAATPKERTEWIKAIQVA",
            )
            self.assertEqual(
                alignment.query.seq[2:96],
                "IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 105)
            self.assertEqual(alignment.shape, (2, 100))
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["identical"], 30)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["positives"], 48)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            self.assertEqual(alignment.annotations["gaps"], 6)
            self.assertAlmostEqual(alignment.annotations["% positives"], 48.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/3")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|296223671|ref|XM_002757683.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|296223671|ref|XM_002757683.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|296223671|ref|XM_002757683.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1183)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    numpy.array([[0, 98], [0, 98]]),
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 160)
            self.assertEqual(alignment.target.annotations["end"], 454)
            self.assertEqual(
                alignment.target.seq,
                "KRIREGYLVKKGSMFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVFKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertEqual(
                alignment.query.seq[0:98],
                "KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.score, 515)
            self.assertEqual(alignment.shape, (2, 98))
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["identical"], 96)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["positives"], 97)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 98.98)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|296223671|ref|XM_002757683.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|296223671|ref|XM_002757683.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|296223671|ref|XM_002757683.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|296223671|ref|XM_002757683.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1183)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[0, 27, 29, 64, 68, 100],
                                 [2, 29, 29, 64, 64,  96]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 865)
            self.assertEqual(alignment.target.annotations["end"], 1165)
            self.assertEqual(
                alignment.target.seq,
                "IKQGCLLKQGHRRKNWKVRKFILREDPAYLHYYDPAGGEDPLGAIHLRGCVVTSVESNSDGRKSEEENLFEIITADEVHYFLQAATPKERTEWIKAIQVA",
            )
            self.assertEqual(
                alignment.query.seq[2:96],
                "IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 105)
            self.assertEqual(alignment.shape, (2, 100))
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["identical"], 30)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["positives"], 48)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            self.assertEqual(alignment.annotations["gaps"], 6)
            self.assertAlmostEqual(alignment.annotations["% positives"], 48.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|338714227|ref|XM_001492113.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|338714227|ref|XM_001492113.3|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|338714227|ref|XM_001492113.3|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1390)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    numpy.array([[0, 98], [0, 98]]),
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 172)
            self.assertEqual(alignment.target.annotations["end"], 466)
            self.assertEqual(
                alignment.target.seq,
                "KRIREGYLVKRGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVFKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertEqual(
                alignment.query.seq[0:98],
                "KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.score, 515)
            self.assertEqual(alignment.shape, (2, 98))
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["identical"], 96)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["positives"], 97)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 98.98)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|338714227|ref|XM_001492113.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|338714227|ref|XM_001492113.3|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|338714227|ref|XM_001492113.3|",
            )
            self.assertEqual(alignment.target.annotations["length"], 1390)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[0, 27, 29, 54, 58, 100],
                                 [2, 29, 29, 54, 54,  96]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 898)
            self.assertEqual(alignment.target.annotations["end"], 1198)
            self.assertEqual(
                alignment.target.seq,
                "IKQGCLLKQGHRRKNWKVRKFVLREDPAYVHYYDPAGGEEPLGAIHLRGCVVTSVEGNPDGKKSEEENLFEIITADEVHYFLQAATPKERTEWIKAIQVA",
            )
            self.assertEqual(
                alignment.query.seq[2:96],
                "IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
            self.assertAlmostEqual(alignment.score, 109)
            self.assertEqual(alignment.shape, (2, 100))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
            self.assertEqual(alignment.annotations["identical"], 31)
            self.assertEqual(alignment.annotations["mismatches"], 63)
            self.assertEqual(alignment.annotations["positives"], 48)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            self.assertEqual(alignment.annotations["gaps"], 6)
            self.assertAlmostEqual(alignment.annotations["% positives"], 48.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/2")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|11464971:4-101")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|11464971:4-101"
            )
            self.assertEqual(len(alignment.query.seq), 98)
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "0")
            self.assertEqual(alignment.target.annotations["gis"], "0")
            self.assertEqual(
                alignment.target.annotations["acc."], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(
                alignment.target.annotations["acc.ver"],
                "gi|365982352|ref|XM_003667962.1|",
            )
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 15, 24, 52],
                                 [11, 26, 26, 54]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.target.annotations["start"], 3180)
            self.assertEqual(alignment.target.annotations["end"], 3336)
            self.assertEqual(
                alignment.target.seq,
                "GSCFPTWDLIFIEVLNPFLKEKLWEADNEEISKFVDLTLKGLVDLYPSHFTS",
            )
            self.assertEqual(
                alignment.query.seq[11:54],
                "GSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTS",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 19.6)
            self.assertAlmostEqual(alignment.score, 39)
            self.assertEqual(alignment.shape, (2, 52))
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.77)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            self.assertEqual(alignment.annotations["gaps"], 9)
            self.assertAlmostEqual(alignment.annotations["% positives"], 44.23)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "0/1")
            self.assertEqual(alignment.query.annotations["frame"], "0")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2226_tblastn_012(self):
        path = "Blast/tab_2226_tblastn_012.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.26+")
            self.assertEqual(alignments.metadata["RID"], "X76FDCG9016")
            self.assertEqual(alignments.metadata["Database"], "refseq_rna")

            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|145479850|ref|XM_001425911.1|")
            self.assertEqual(alignment.query.annotations["start"], 30)
            self.assertEqual(alignment.query.annotations["end"], 73)
            self.assertEqual(alignment.target.annotations["start"], 1743)
            self.assertEqual(alignment.target.annotations["end"], 1872)
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.76)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.88)
            self.assertEqual(alignment.annotations["alignment length"], 43)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|115975252|ref|XM_001180111.1|")
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1056)
            self.assertEqual(alignment.target.annotations["end"], 1233)
            self.assertAlmostEqual(alignment.annotations["evalue"], 7.2)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|16080617|ref|NP_391444.1|")
            self.assertEqual(alignment.target.id, "gi|390342090|ref|XM_777959.2|")
            self.assertEqual(alignment.query.annotations["start"], 43)
            self.assertEqual(alignment.query.annotations["end"], 94)
            self.assertEqual(alignment.target.annotations["start"], 1266)
            self.assertEqual(alignment.target.annotations["end"], 1443)
            self.assertAlmostEqual(alignment.annotations["evalue"], 7.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.90)
            self.assertEqual(alignment.annotations["alignment length"], 59)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 1)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|354480463|ref|XM_003502378.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 75)
            self.assertEqual(alignment.target.annotations["end"], 369)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-63)
            self.assertAlmostEqual(alignment.annotations["bit score"], 205)
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|354480463|ref|XM_003502378.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 801)
            self.assertEqual(alignment.target.annotations["end"], 1101)
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 43.9)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 3)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 94)
            self.assertEqual(alignment.target.annotations["end"], 388)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-62)
            self.assertAlmostEqual(alignment.annotations["bit score"], 199)
            self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 4)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|350596019|ref|XM_003360601.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 29)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 541)
            self.assertEqual(alignment.target.annotations["end"], 754)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 32.7)
            self.assertAlmostEqual(alignment.annotations["% identity"], 29.58)
            self.assertEqual(alignment.annotations["alignment length"], 71)
            self.assertEqual(alignment.annotations["mismatches"], 46)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 77)
            self.assertEqual(alignment.target.annotations["end"], 371)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-62)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|301779869|ref|XM_002925302.1|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 803)
            self.assertEqual(alignment.target.annotations["end"], 1103)
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 64)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 172)
            self.assertEqual(alignment.target.annotations["end"], 466)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-61)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|338714227|ref|XM_001492113.3|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 96)
            self.assertEqual(alignment.target.annotations["start"], 898)
            self.assertEqual(alignment.target.annotations["end"], 1198)
            self.assertAlmostEqual(alignment.annotations["evalue"], 9e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
            self.assertEqual(alignment.annotations["alignment length"], 100)
            self.assertEqual(alignment.annotations["mismatches"], 63)
            self.assertEqual(alignment.annotations["gap opens"], 2)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|11464971:4-101")
            self.assertEqual(alignment.target.id, "gi|390474391|ref|XM_002757683.2|")
            self.assertEqual(alignment.query.description, "pleckstrin [Mus musculus]")
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 98)
            self.assertEqual(alignment.target.annotations["start"], 160)
            self.assertEqual(alignment.target.annotations["end"], 454)
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-61)
            self.assertAlmostEqual(alignment.annotations["bit score"], 202)
            self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
            self.assertEqual(alignment.annotations["alignment length"], 98)
            self.assertEqual(alignment.annotations["mismatches"], 2)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2228_tblastn_001(self):
        path = "Blast/tab_2228_tblastn_001.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTN")
            self.assertEqual(alignments.metadata["Version"], "2.2.28+")
            self.assertEqual(alignments.metadata["RID"], "M6BMVNA2015")
            self.assertEqual(alignments.metadata["Database"], "nr")

            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|148227873|ref|NM_001095167.1|;gi|55250552|gb|BC086280.1|",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|512812550|ref|XM_002935781.2|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|512812554|ref|XM_004910718.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|327289356|ref|XM_003229343.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|602661018|ref|XM_007436108.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|564242014|ref|XM_006277753.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.0)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|591387858|ref|XM_007068281.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-180)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|558185265|ref|XM_006128143.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-180)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|573878747|ref|XM_006627536.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-173)
            alignment = next(alignments)
            self.assertEqual(alignment.query.id, "gi|148227874|ref|NP_001088636.1|")
            self.assertEqual(alignment.query.description, "sirtuin 2 [Xenopus laevis]")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410910671|ref|XM_003968765.1|"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-173)
            with self.assertRaises(StopIteration):
                next(alignments)

    def test_2228_tblastx_001(self):
        path = "Blast/tab_2228_tblastx_001.txt"
        with open(path) as stream:
            alignments = Align.parse(stream, "tabular")
            self.assertEqual(alignments.metadata["Program"], "TBLASTX")
            self.assertEqual(alignments.metadata["Version"], "2.2.28+")
            self.assertEqual(alignments.metadata["RID"], "P06P5RN0015")
            self.assertEqual(alignments.metadata["Database"], "refseq_rna")
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [  1, 117]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 1)
            self.assertEqual(alignment.query.annotations["end"], 349)
            self.assertEqual(alignment.target.annotations["start"], 1)
            self.assertEqual(alignment.target.annotations["end"], 349)
            self.assertEqual(
                alignment.target.seq,
                "WP*TLEGLTPCKGNLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
            )
            self.assertEqual(
                alignment.query.seq,
                "WP*TLEGLTPCKGNLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-76)
            self.assertAlmostEqual(alignment.annotations["bit score"], 289)
            self.assertAlmostEqual(alignment.score, 626)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 116)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 116)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [349, 233]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 348)
            self.assertEqual(alignment.query.annotations["end"], 2)
            self.assertEqual(alignment.target.annotations["start"], 348)
            self.assertEqual(alignment.target.annotations["end"], 2)
            self.assertEqual(
                alignment.target.seq,
                "LLIESPSRDE*PQ*RHPKFQTAGFEE*MERLTVPVGIALPGSSF*HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAFAWSQTLQCSWP",
            )
            self.assertEqual(
                alignment.query.seq,
                "LLIESPSRDE*PQ*RHPKFQTAGFEE*MERLTVPVGIALPGSSF*HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAFAWSQTLQCSWP",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-73)
            self.assertAlmostEqual(alignment.annotations["bit score"], 278)
            self.assertAlmostEqual(alignment.score, 602)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 116)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 116)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-3")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [348, 232]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 347)
            self.assertEqual(alignment.query.annotations["end"], 1)
            self.assertEqual(alignment.target.annotations["start"], 347)
            self.assertEqual(alignment.target.annotations["end"], 1)
            self.assertEqual(
                alignment.target.seq,
                "F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
            )
            self.assertEqual(
                alignment.query.seq,
                "F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-72)
            self.assertAlmostEqual(alignment.annotations["bit score"], 274)
            self.assertAlmostEqual(alignment.score, 593)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 116)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 116)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [  2, 118]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 2)
            self.assertEqual(alignment.query.annotations["end"], 350)
            self.assertEqual(alignment.target.annotations["start"], 2)
            self.assertEqual(alignment.target.annotations["end"], 350)
            self.assertEqual(
                alignment.target.seq,
                "GHEHWRV*LHAKAT*SRIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS",
            )
            self.assertEqual(
                alignment.query.seq,
                "GHEHWRV*LHAKAT*SRIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-70)
            self.assertAlmostEqual(alignment.annotations["bit score"], 270)
            self.assertAlmostEqual(alignment.score, 583)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 116)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 116)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "3/3")
            self.assertEqual(alignment.query.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [350, 234]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 3)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 3)
            self.assertEqual(
                alignment.target.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPPVFMA",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPPVFMA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-58)
            self.assertAlmostEqual(alignment.annotations["bit score"], 229)
            self.assertAlmostEqual(alignment.score, 495)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 116)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 116)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  85],
                                 [ 93, 178]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 93)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-53)
            self.assertAlmostEqual(alignment.annotations["bit score"], 197)
            self.assertAlmostEqual(alignment.score, 425)
            self.assertEqual(alignment.shape, (2, 85))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 85)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 85)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 73)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 14],
                                 [ 0, 14]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296147483|ref|NM_001183135.1|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|296147483|ref|NM_001183135.1|;gi|116616412|gb|EF059095.1|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "296147483")
            self.assertEqual(alignment.target.annotations["gis"], "296147483;116616412")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001183135")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_001183135;EF059095"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001183135.1")
            self.assertEqual(alignment.target.annotations["length"], 4911)
            self.assertEqual(alignment.query.annotations["start"], 0)
            self.assertEqual(alignment.query.annotations["end"], 42)
            self.assertEqual(alignment.target.annotations["start"], 0)
            self.assertEqual(alignment.target.annotations["end"], 42)
            self.assertEqual(alignment.target.seq, "MAMNTGGFDSMQRQ")
            self.assertEqual(alignment.query.seq, "MAMNTGGFDSMQRQ")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-53)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 14))
            self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 0)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 100.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "32630;559292")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A;N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Saccharomyces cerevisiae S288c Mon2p (MON2), mRNA<>Synthetic construct Saccharomyces cerevisiae clone FLH203015.01X MON2, complete sequence",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 12)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  85],
                                 [ 93, 178]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 93)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 87)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "TIKHASDKSIDILKTIQNIEELVRHPDFVTPLVLACSSRNAKLTSIAMQCLQGLASVPSIPESRIPEVLDGFIEATQLAMEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-37)
            self.assertAlmostEqual(alignment.annotations["bit score"], 152)
            self.assertAlmostEqual(alignment.score, 327)
            self.assertEqual(alignment.shape, (2, 85))
            self.assertAlmostEqual(alignment.annotations["% identity"], 72.94)
            self.assertEqual(alignment.annotations["identical"], 62)
            self.assertEqual(alignment.annotations["mismatches"], 23)
            self.assertEqual(alignment.annotations["positives"], 73)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 85.88)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 73)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 14],
                                 [68, 82]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 68)
            self.assertEqual(alignment.query.annotations["end"], 110)
            self.assertEqual(alignment.target.annotations["start"], 62)
            self.assertEqual(alignment.target.annotations["end"], 104)
            self.assertEqual(alignment.target.seq, "FRI*KKKFNH*TC*")
            self.assertEqual(alignment.query.seq, "FRIEKKKFNHSPC*")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-37)
            self.assertAlmostEqual(alignment.annotations["bit score"], 26.3)
            self.assertAlmostEqual(alignment.score, 51)
            self.assertEqual(alignment.shape, (2, 14))
            self.assertAlmostEqual(alignment.annotations["% identity"], 78.57)
            self.assertEqual(alignment.annotations["identical"], 11)
            self.assertEqual(alignment.annotations["mismatches"], 3)
            self.assertEqual(alignment.annotations["positives"], 11)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 78.57)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "3/3")
            self.assertEqual(alignment.query.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 12)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [350, 295]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 186)
            self.assertEqual(alignment.target.annotations["start"], 343)
            self.assertEqual(alignment.target.annotations["end"], 180)
            self.assertEqual(
                alignment.target.seq,
                "TFNCISIAS*VASMNPSRTSGILDSGIEGTDANPCRHCMAIEVNLAFLDEQARTK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20)
            self.assertAlmostEqual(alignment.annotations["bit score"], 68.0)
            self.assertAlmostEqual(alignment.score, 142)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 61.82)
            self.assertEqual(alignment.annotations["identical"], 34)
            self.assertEqual(alignment.annotations["mismatches"], 21)
            self.assertEqual(alignment.annotations["positives"], 38)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 69.09)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  39],
                                 [137,  98]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 136)
            self.assertEqual(alignment.query.annotations["end"], 21)
            self.assertEqual(alignment.target.annotations["start"], 130)
            self.assertEqual(alignment.target.annotations["end"], 15)
            self.assertEqual(
                alignment.target.seq, "VFRISIDLSLACLMVEFLLLDSEERECNSWSNCFRKEVN"
            )
            self.assertEqual(
                alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESN"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20)
            self.assertAlmostEqual(alignment.annotations["bit score"], 52.8)
            self.assertAlmostEqual(alignment.score, 109)
            self.assertEqual(alignment.shape, (2, 39))
            self.assertAlmostEqual(alignment.annotations["% identity"], 61.54)
            self.assertEqual(alignment.annotations["identical"], 24)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.36)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 33)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 103],
                                 [ 40, 143]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 40)
            self.assertEqual(alignment.query.annotations["end"], 349)
            self.assertEqual(alignment.target.annotations["start"], 34)
            self.assertEqual(alignment.target.annotations["end"], 343)
            self.assertEqual(
                alignment.target.seq,
                "NWTRNYTPFLQNLKEEIQPLNMLATNQSIF*RLFKI*KNL*GTLILLHLWSWPVHREMPN*LQLPCNAYKDWRPYLQYQSQESQKF*TDSLKPLS*RWRYN*K",
            )
            self.assertEqual(
                alignment.query.seq,
                "NLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 9e-08)
            self.assertAlmostEqual(alignment.annotations["bit score"], 61.1)
            self.assertAlmostEqual(alignment.score, 127)
            self.assertEqual(alignment.shape, (2, 103))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.95)
            self.assertEqual(alignment.annotations["identical"], 36)
            self.assertEqual(alignment.annotations["mismatches"], 67)
            self.assertEqual(alignment.annotations["positives"], 52)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.49)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 88)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [261, 196]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|365982352|ref|XM_003667962.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|365982352|ref|XM_003667962.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "365982352")
            self.assertEqual(alignment.target.annotations["gis"], "365982352")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003667962")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003667962.1")
            self.assertEqual(alignment.target.annotations["length"], 4932)
            self.assertEqual(alignment.query.annotations["start"], 260)
            self.assertEqual(alignment.query.annotations["end"], 67)
            self.assertEqual(alignment.target.annotations["start"], 254)
            self.assertEqual(alignment.target.annotations["end"], 61)
            self.assertEqual(
                alignment.target.seq,
                "GRQSL*ALHGN*S*FGISR*TGQDQRCNKIRVPYKFFYILNSL*NID*FVASMFNG*ISSFRF*R",
            )
            self.assertEqual(
                alignment.query.seq,
                "G*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.029)
            self.assertAlmostEqual(alignment.annotations["bit score"], 42.8)
            self.assertAlmostEqual(alignment.score, 87)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 36)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.38)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071378")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma dairenensis CBS 421 hypothetical protein (NDAI0A06120), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  85],
                                 [ 93, 178]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366988334|ref|XM_003673886.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366988334|ref|XM_003673886.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366988334")
            self.assertEqual(alignment.target.annotations["gis"], "366988334")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003673886.1")
            self.assertEqual(alignment.target.annotations["length"], 4938)
            self.assertEqual(alignment.query.annotations["start"], 93)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "SIKHASDKSIEILKTIQNIEDLASHPDFVTPLVESCLSRNAKLTSIAMQCLQGLASAPSIPESRLSGVLDGFIEATHLAIEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-32)
            self.assertAlmostEqual(alignment.annotations["bit score"], 143)
            self.assertAlmostEqual(alignment.score, 306)
            self.assertEqual(alignment.shape, (2, 85))
            self.assertAlmostEqual(alignment.annotations["% identity"], 68.24)
            self.assertEqual(alignment.annotations["identical"], 58)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 71)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 83.53)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1064592")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 73)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  54],
                                 [350, 296]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366988334|ref|XM_003673886.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366988334|ref|XM_003673886.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366988334")
            self.assertEqual(alignment.target.annotations["gis"], "366988334")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003673886.1")
            self.assertEqual(alignment.target.annotations["length"], 4938)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 189)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 189)
            self.assertEqual(
                alignment.target.seq,
                "TFSCISIARCVASINPSRTPDSLLSGMDGADAKPCKHCIAIEVNLAFLDRHDST",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANT",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16)
            self.assertAlmostEqual(alignment.annotations["bit score"], 62.5)
            self.assertAlmostEqual(alignment.score, 130)
            self.assertEqual(alignment.shape, (2, 54))
            self.assertAlmostEqual(alignment.annotations["% identity"], 55.56)
            self.assertEqual(alignment.annotations["identical"], 30)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 36)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1064592")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 46)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  33],
                                 [137, 104]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366988334|ref|XM_003673886.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366988334|ref|XM_003673886.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366988334")
            self.assertEqual(alignment.target.annotations["gis"], "366988334")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003673886.1")
            self.assertEqual(alignment.target.annotations["length"], 4938)
            self.assertEqual(alignment.query.annotations["start"], 136)
            self.assertEqual(alignment.query.annotations["end"], 39)
            self.assertEqual(alignment.target.annotations["start"], 136)
            self.assertEqual(alignment.target.annotations["end"], 39)
            self.assertEqual(alignment.target.seq, "VFKISIDLSLACLIEVFLLLDSEDNECNSRSNC")
            self.assertEqual(alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSC")
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16)
            self.assertAlmostEqual(alignment.annotations["bit score"], 44.6)
            self.assertAlmostEqual(alignment.score, 91)
            self.assertEqual(alignment.shape, (2, 33))
            self.assertAlmostEqual(alignment.annotations["% identity"], 60.61)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 24)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 72.73)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1064592")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 28)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 115],
                                 [345, 230]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366988334|ref|XM_003673886.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366988334|ref|XM_003673886.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366988334")
            self.assertEqual(alignment.target.annotations["gis"], "366988334")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003673886")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003673886.1")
            self.assertEqual(alignment.target.annotations["length"], 4938)
            self.assertEqual(alignment.query.annotations["start"], 344)
            self.assertEqual(alignment.query.annotations["end"], 1)
            self.assertEqual(alignment.target.annotations["start"], 344)
            self.assertEqual(alignment.target.annotations["end"], 1)
            self.assertEqual(
                alignment.target.seq,
                "*LYFNCKMCRFYKSIENSR*SAFRYGWCRC*AL*TLHSNRGQLSVP**T*FYQWSDKIRMACQIFNVLDSF*DLDRLVTCMLDRSVPSFRFGRQ*MQF*VQLFLKGLKTCSLNSH",
            )
            self.assertEqual(
                alignment.query.seq,
                "*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 54.2)
            self.assertAlmostEqual(alignment.score, 112)
            self.assertEqual(alignment.shape, (2, 115))
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.04)
            self.assertEqual(alignment.annotations["identical"], 38)
            self.assertEqual(alignment.annotations["mismatches"], 77)
            self.assertEqual(alignment.annotations["positives"], 58)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.43)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1064592")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Naumovozyma castellii CBS 4309 hypothetical protein (NCAS0A09950) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|255710474|ref|XM_002551475.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|255710474|ref|XM_002551475.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "255710474")
            self.assertEqual(alignment.target.annotations["gis"], "255710474")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002551475")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002551475")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002551475.1")
            self.assertEqual(alignment.target.annotations["length"], 4845)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "VRHASDKSIEILKTVHEFEDLPRHPDFVTPFVLSCASKNAKLTSVSVQCLQKMSSVNCIPEDRIEDVLDAFIDSTHLAAEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-32)
            self.assertAlmostEqual(alignment.annotations["bit score"], 141)
            self.assertAlmostEqual(alignment.score, 303)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.48)
            self.assertEqual(alignment.annotations["identical"], 55)
            self.assertEqual(alignment.annotations["mismatches"], 29)
            self.assertEqual(alignment.annotations["positives"], 71)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 84.52)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559295")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Lachancea thermotolerans CBS 6340 KLTH0A01342p (KLTH0A01342g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Lachancea thermotolerans CBS 6340 KLTH0A01342p (KLTH0A01342g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 73)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [350, 295]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|255710474|ref|XM_002551475.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|255710474|ref|XM_002551475.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "255710474")
            self.assertEqual(alignment.target.annotations["gis"], "255710474")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002551475")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002551475")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002551475.1")
            self.assertEqual(alignment.target.annotations["length"], 4845)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 186)
            self.assertEqual(alignment.target.annotations["start"], 346)
            self.assertEqual(alignment.target.annotations["end"], 183)
            self.assertEqual(
                alignment.target.seq,
                "TLSCISAARWVESMNASSTSSILSSGMQLTDDIFCRHCTETLVSLAFLEAHERTK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 45.45)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 30)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.73)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "559295")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Lachancea thermotolerans CBS 6340 KLTH0A01342p (KLTH0A01342g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Lachancea thermotolerans CBS 6340 KLTH0A01342p (KLTH0A01342g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 73)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|254579534|ref|XM_002495708.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|254579534|ref|XM_002495708.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "254579534")
            self.assertEqual(alignment.target.annotations["gis"], "254579534")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002495708.1")
            self.assertEqual(alignment.target.annotations["length"], 4866)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 96)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "IRNASDKSIEILKVVHSYEELSRHPDFIVPLVMSCASKNAKLTTISMQCFQKLATVPCIPVDKLSDVLDAFIEANQLAMDIKLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6e-32)
            self.assertAlmostEqual(alignment.annotations["bit score"], 141)
            self.assertAlmostEqual(alignment.score, 302)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 67.86)
            self.assertEqual(alignment.annotations["identical"], 57)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 72)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 85.71)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559307")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  49],
                                 [350, 301]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|254579534|ref|XM_002495708.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|254579534|ref|XM_002495708.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "254579534")
            self.assertEqual(alignment.target.annotations["gis"], "254579534")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002495708.1")
            self.assertEqual(alignment.target.annotations["length"], 4866)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 204)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 204)
            self.assertEqual(
                alignment.target.seq,
                "TFSFISIASWLASINASSTSESLSTGIHGTVANFWKHCIDIVVNLAFLD",
            )
            self.assertEqual(
                alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLD"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 51.0)
            self.assertAlmostEqual(alignment.score, 105)
            self.assertEqual(alignment.shape, (2, 49))
            self.assertAlmostEqual(alignment.annotations["% identity"], 55.10)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 33)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.35)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "559307")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 42)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  42],
                                 [140,  98]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|254579534|ref|XM_002495708.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|254579534|ref|XM_002495708.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "254579534")
            self.assertEqual(alignment.target.annotations["gis"], "254579534")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002495708.1")
            self.assertEqual(alignment.target.annotations["length"], 4866)
            self.assertEqual(alignment.query.annotations["start"], 139)
            self.assertEqual(alignment.query.annotations["end"], 15)
            self.assertEqual(alignment.target.annotations["start"], 139)
            self.assertEqual(alignment.target.annotations["end"], 15)
            self.assertEqual(
                alignment.target.seq, "TTFKISIDLSLAFLIAVFLFFDSDESECNSELSSFQKLPNSP"
            )
            self.assertEqual(
                alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPP"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 41.8)
            self.assertAlmostEqual(alignment.score, 85)
            self.assertEqual(alignment.shape, (2, 42))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.62)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 25)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 59.52)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "559307")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 36)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  99],
                                 [ 50, 149]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|254579534|ref|XM_002495708.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|254579534|ref|XM_002495708.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "254579534")
            self.assertEqual(alignment.target.annotations["gis"], "254579534")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002495708")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002495708.1")
            self.assertEqual(alignment.target.annotations["length"], 4866)
            self.assertEqual(alignment.query.annotations["start"], 50)
            self.assertEqual(alignment.query.annotations["end"], 347)
            self.assertEqual(alignment.target.annotations["start"], 50)
            self.assertEqual(alignment.target.annotations["end"], 347)
            self.assertEqual(
                alignment.target.seq,
                "RVAFTFIRVEEKEYCY*EC*R*IN*NFESSSQL*GIIKTSRFYSTASDVMCIQECQIDYYINAMFPKIGHSAMYTGR*TLRRT*CVYRGQPAGNGYKTK",
            )
            self.assertEqual(
                alignment.query.seq,
                "RIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 99))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.31)
            self.assertEqual(alignment.annotations["identical"], 31)
            self.assertEqual(alignment.annotations["mismatches"], 68)
            self.assertEqual(alignment.annotations["positives"], 53)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 53.54)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "3/3")
            self.assertEqual(alignment.query.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "559307")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Zygosaccharomyces rouxii hypothetical protein (ZYRO0C02266g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 85)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 96)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "VKHASDKSIEILKTVTNINDLTRHPDFVVPFILACSSGNAKLTSISMQCIQVISTVQCIPSTRISEILDAFINATHLAVEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-31)
            self.assertAlmostEqual(alignment.annotations["bit score"], 139)
            self.assertAlmostEqual(alignment.score, 299)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 66.67)
            self.assertEqual(alignment.annotations["identical"], 56)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["positives"], 71)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 84.52)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [  1, 117]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 1)
            self.assertEqual(alignment.query.annotations["end"], 349)
            self.assertEqual(alignment.target.annotations["start"], 1)
            self.assertEqual(alignment.target.annotations["end"], 349)
            self.assertEqual(
                alignment.target.seq,
                "WQLNLLILQPLKSN*LQTYNLYLLNRKEKVQMLNTLVINLLKF*KL*LI*MI*QDIQIS*YHSFWHVLQEMQS*LQFLCNAFKLYQLYNVYQVLEFLKF*MLLLMLLI*RWKYN*K",
            )
            self.assertEqual(
                alignment.query.seq,
                "WP*TLEGLTPCKGNLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-14)
            self.assertAlmostEqual(alignment.annotations["bit score"], 81.3)
            self.assertAlmostEqual(alignment.score, 171)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 42.24)
            self.assertEqual(alignment.annotations["identical"], 49)
            self.assertEqual(alignment.annotations["mismatches"], 67)
            self.assertEqual(alignment.annotations["positives"], 66)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 56.90)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 116],
                                 [348, 232]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 347)
            self.assertEqual(alignment.query.annotations["end"], 1)
            self.assertEqual(alignment.target.annotations["start"], 347)
            self.assertEqual(alignment.target.annotations["end"], 1)
            self.assertEqual(
                alignment.target.seq,
                "F*LYFHR*MSSINKSI*NFRNSSTWYTLYS*YNLNALHRN*S*LCIS*RTCQNEWYYEIWMSC*IIYISYSFQNFNRFITSVFNICTFSFRFRR*RL*VCSQLLFKGCKIKRFNCH",
            )
            self.assertEqual(
                alignment.query.seq,
                "F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 72.1)
            self.assertAlmostEqual(alignment.score, 151)
            self.assertEqual(alignment.shape, (2, 116))
            self.assertAlmostEqual(alignment.annotations["% identity"], 42.24)
            self.assertEqual(alignment.annotations["identical"], 49)
            self.assertEqual(alignment.annotations["mismatches"], 67)
            self.assertEqual(alignment.annotations["positives"], 60)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.72)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 99)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  47],
                                 [350, 303]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 210)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 210)
            self.assertEqual(
                alignment.target.seq, "TFNCISTAK*VALIKASKISEILVLGIHCTVDIT*MHCIEIEVSFAF"
            )
            self.assertEqual(
                alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAF"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 47.3)
            self.assertAlmostEqual(alignment.score, 97)
            self.assertEqual(alignment.shape, (2, 47))
            self.assertAlmostEqual(alignment.annotations["% identity"], 55.32)
            self.assertEqual(alignment.annotations["identical"], 26)
            self.assertEqual(alignment.annotations["mismatches"], 21)
            self.assertEqual(alignment.annotations["positives"], 30)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.83)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 40)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  60],
                                 [214, 154]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 213)
            self.assertEqual(alignment.query.annotations["end"], 35)
            self.assertEqual(alignment.target.annotations["start"], 213)
            self.assertEqual(alignment.target.annotations["end"], 35)
            self.assertEqual(
                alignment.target.seq,
                "HFLKNMPK*MVLRNLDVLLNHLY*LQFSKFQ*IYH*RV*HLYFFFSIQKIKIVSL*SIAF",
            )
            self.assertEqual(
                alignment.query.seq,
                "HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAF",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.5)
            self.assertAlmostEqual(alignment.score, 82)
            self.assertEqual(alignment.shape, (2, 60))
            self.assertAlmostEqual(alignment.annotations["% identity"], 45.00)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 33)
            self.assertEqual(alignment.annotations["positives"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-3")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 51)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 105],
                                 [ 35, 140]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 35)
            self.assertEqual(alignment.query.annotations["end"], 350)
            self.assertEqual(alignment.target.annotations["start"], 35)
            self.assertEqual(alignment.target.annotations["end"], 350)
            self.assertEqual(
                alignment.target.seq,
                "KAIDYRLTIFIF*IEKKKYRC*TR***IY*NFENCN*YK*FNKTSRFRSTIHFGMFFRKCKANFNFYAMHSSYINCTMYTKY*NF*NFRCFY*CYSFSGGNTIKS",
            )
            self.assertEqual(
                alignment.query.seq,
                "KAT*SRIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-08)
            self.assertAlmostEqual(alignment.annotations["bit score"], 62.5)
            self.assertAlmostEqual(alignment.score, 130)
            self.assertEqual(alignment.shape, (2, 105))
            self.assertAlmostEqual(alignment.annotations["% identity"], 38.10)
            self.assertEqual(alignment.annotations["identical"], 40)
            self.assertEqual(alignment.annotations["mismatches"], 65)
            self.assertEqual(alignment.annotations["positives"], 58)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.24)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "3/3")
            self.assertEqual(alignment.query.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 90)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  34],
                                 [140, 106]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156843402|ref|XM_001644719.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156843402|ref|XM_001644719.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156843402")
            self.assertEqual(alignment.target.annotations["gis"], "156843402")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001644719")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001644719.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 139)
            self.assertEqual(alignment.query.annotations["end"], 39)
            self.assertEqual(alignment.target.annotations["start"], 139)
            self.assertEqual(alignment.target.annotations["end"], 39)
            self.assertEqual(alignment.target.seq, "TVFKISIDLSLACLTSVLFLFDSEDKDCKSVVNC")
            self.assertEqual(alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSC")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.19)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.0)
            self.assertAlmostEqual(alignment.score, 81)
            self.assertEqual(alignment.shape, (2, 34))
            self.assertAlmostEqual(alignment.annotations["% identity"], 52.94)
            self.assertEqual(alignment.annotations["identical"], 18)
            self.assertEqual(alignment.annotations["mismatches"], 16)
            self.assertEqual(alignment.annotations["positives"], 22)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.71)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "436907")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Vanderwaltozyma polyspora DSM 70294 hypothetical protein (Kpol_1020p19) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 100)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 29)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410075642|ref|XM_003955355.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410075642|ref|XM_003955355.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410075642")
            self.assertEqual(alignment.target.annotations["gis"], "410075642")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003955355")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003955355")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003955355.1")
            self.assertEqual(alignment.target.annotations["length"], 4881)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 96)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "VKHASEKSLKILKTVHDSGDFLRHPDFVVPFVLACSSRSAKLTTIGLQGLQNLSSTNCIPKDRLIEVLDGFIDATHLAMEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28)
            self.assertAlmostEqual(alignment.annotations["bit score"], 129)
            self.assertAlmostEqual(alignment.score, 276)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 61.90)
            self.assertEqual(alignment.annotations["identical"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 32)
            self.assertEqual(alignment.annotations["positives"], 67)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 79.76)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071382")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Kazachstania africana CBS 2517 hypothetical protein (KAFR0A08350), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Kazachstania africana CBS 2517 hypothetical protein (KAFR0A08350), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 105],
                                 [350, 245]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410075642|ref|XM_003955355.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410075642|ref|XM_003955355.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410075642")
            self.assertEqual(alignment.target.annotations["gis"], "410075642")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003955355")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003955355")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003955355.1")
            self.assertEqual(alignment.target.annotations["length"], 4881)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 36)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 36)
            self.assertEqual(
                alignment.target.seq,
                "TFS*ISIAKCVASINPSNTSINRSLGIQLVDDKFCKP*RPIVVNLALRDEQAKTNGTTKSGCLRKSPLSCTVFKILRDFSLACLTSEFLLLASDDKE*SPVSSCL",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 67.5)
            self.assertAlmostEqual(alignment.score, 141)
            self.assertEqual(alignment.shape, (2, 105))
            self.assertAlmostEqual(alignment.annotations["% identity"], 49.52)
            self.assertEqual(alignment.annotations["identical"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 53)
            self.assertEqual(alignment.annotations["positives"], 61)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.10)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071382")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Kazachstania africana CBS 2517 hypothetical protein (KAFR0A08350), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Kazachstania africana CBS 2517 hypothetical protein (KAFR0A08350), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 90)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|47073627|ref|NM_210010.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|47073627|ref|NM_210010.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "47073627")
            self.assertEqual(alignment.target.annotations["gis"], "47073627")
            self.assertEqual(alignment.target.annotations["acc."], "NM_210010")
            self.assertEqual(alignment.target.annotations["accs."], "NM_210010")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_210010.1")
            self.assertEqual(alignment.target.annotations["length"], 4776)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "VKHASDRSLQILRIVHSFEELERHPDFILPFVLSCKSGNAKFTSLSMQSLQRLAIHQSIPREQIEHVLEALIDSTQLAVEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28)
            self.assertAlmostEqual(alignment.annotations["bit score"], 129)
            self.assertAlmostEqual(alignment.score, 276)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 61.90)
            self.assertEqual(alignment.annotations["identical"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 32)
            self.assertEqual(alignment.annotations["positives"], 70)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 83.33)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284811")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 110],
                                 [350, 240]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|47073627|ref|NM_210010.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|47073627|ref|NM_210010.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "47073627")
            self.assertEqual(alignment.target.annotations["gis"], "47073627")
            self.assertEqual(alignment.target.annotations["acc."], "NM_210010")
            self.assertEqual(alignment.target.annotations["accs."], "NM_210010")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_210010.1")
            self.assertEqual(alignment.target.annotations["length"], 4776)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 21)
            self.assertEqual(alignment.target.annotations["start"], 346)
            self.assertEqual(alignment.target.annotations["end"], 18)
            self.assertEqual(
                alignment.target.seq,
                "TFS*ISTASCVESISASSTCSICSRGIDWWIARRCRLCIDSEVNFAFPDLHERTNGRIKSGCRSSSSKLWTIRNICNERSLACFTSELRRLDSEARACRSCVSCLTVLVN",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESN",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 52.4)
            self.assertAlmostEqual(alignment.score, 108)
            self.assertEqual(alignment.shape, (2, 110))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.55)
            self.assertEqual(alignment.annotations["identical"], 49)
            self.assertEqual(alignment.annotations["mismatches"], 61)
            self.assertEqual(alignment.annotations["positives"], 56)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.91)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "284811")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 94)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0, 104],
                                 [348, 244]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|47073627|ref|NM_210010.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|47073627|ref|NM_210010.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "47073627")
            self.assertEqual(alignment.target.annotations["gis"], "47073627")
            self.assertEqual(alignment.target.annotations["acc."], "NM_210010")
            self.assertEqual(alignment.target.annotations["accs."], "NM_210010")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_210010.1")
            self.assertEqual(alignment.target.annotations["length"], 4776)
            self.assertEqual(alignment.query.annotations["start"], 347)
            self.assertEqual(alignment.query.annotations["end"], 37)
            self.assertEqual(alignment.target.annotations["start"], 344)
            self.assertEqual(alignment.target.annotations["end"], 34)
            self.assertEqual(
                alignment.target.seq,
                "F*LNLNGQLCGINQCFEYMFYLLPWNRLVDSQTLQTLH*QRSKLRIS*LT*EDERKNKVWVSF*FFKTMDYPQYL*RAIACMFHFRITSLRFRS*GVQILCQLP",
            )
            self.assertEqual(
                alignment.query.seq,
                "F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLP",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 50.1)
            self.assertAlmostEqual(alignment.score, 103)
            self.assertEqual(alignment.shape, (2, 104))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.58)
            self.assertEqual(alignment.annotations["identical"], 37)
            self.assertEqual(alignment.annotations["mismatches"], 67)
            self.assertEqual(alignment.annotations["positives"], 52)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284811")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ashbya gossypii ATCC 10895 AEL204Cp (AGOS_AEL204C) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 94)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 89)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50294190|ref|XM_449507.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50294190|ref|XM_449507.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50294190")
            self.assertEqual(alignment.target.annotations["gis"], "50294190")
            self.assertEqual(alignment.target.annotations["acc."], "XM_449507")
            self.assertEqual(alignment.target.annotations["accs."], "XM_449507")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_449507.1")
            self.assertEqual(alignment.target.annotations["length"], 4980)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 183)
            self.assertEqual(alignment.target.annotations["end"], 435)
            self.assertEqual(
                alignment.target.seq,
                "VKEASHKSIEILKTIKTINDLENHPDFVVPFALACKTKNAKMTTIAMQCLQNMASTRCIPEKRMDMILDAFIEATQLAMDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-28)
            self.assertAlmostEqual(alignment.annotations["bit score"], 128)
            self.assertAlmostEqual(alignment.score, 274)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 60.71)
            self.assertEqual(alignment.annotations["identical"], 51)
            self.assertEqual(alignment.annotations["mismatches"], 33)
            self.assertEqual(alignment.annotations["positives"], 66)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 78.57)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284593")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  48],
                                 [350, 302]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50294190|ref|XM_449507.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50294190|ref|XM_449507.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50294190")
            self.assertEqual(alignment.target.annotations["gis"], "50294190")
            self.assertEqual(alignment.target.annotations["acc."], "XM_449507")
            self.assertEqual(alignment.target.annotations["accs."], "XM_449507")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_449507.1")
            self.assertEqual(alignment.target.annotations["length"], 4980)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 207)
            self.assertEqual(alignment.target.annotations["start"], 436)
            self.assertEqual(alignment.target.annotations["end"], 294)
            self.assertEqual(
                alignment.target.seq, "TFNCISMASCVASINASNIISILFSGIHLVEAMFCRHCIAIVVILAFL"
            )
            self.assertEqual(
                alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 49.2)
            self.assertAlmostEqual(alignment.score, 101)
            self.assertEqual(alignment.shape, (2, 48))
            self.assertAlmostEqual(alignment.annotations["% identity"], 56.25)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 21)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.42)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "284593")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 41)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  34],
                                 [137, 103]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50294190|ref|XM_449507.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50294190|ref|XM_449507.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50294190")
            self.assertEqual(alignment.target.annotations["gis"], "50294190")
            self.assertEqual(alignment.target.annotations["acc."], "XM_449507")
            self.assertEqual(alignment.target.annotations["accs."], "XM_449507")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_449507.1")
            self.assertEqual(alignment.target.annotations["length"], 4980)
            self.assertEqual(alignment.query.annotations["start"], 136)
            self.assertEqual(alignment.query.annotations["end"], 36)
            self.assertEqual(alignment.target.annotations["start"], 223)
            self.assertEqual(alignment.target.annotations["end"], 123)
            self.assertEqual(alignment.target.seq, "VFNISIDLWLASLTSELRLRASATSA*RSASNCL")
            self.assertEqual(alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 27.6)
            self.assertAlmostEqual(alignment.score, 54)
            self.assertEqual(alignment.shape, (2, 34))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.06)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 18)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.88)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "284593")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida glabrata CBS 138 hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 29)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|444314872|ref|XM_004178046.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|444314872|ref|XM_004178046.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "444314872")
            self.assertEqual(alignment.target.annotations["gis"], "444314872")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004178046.1")
            self.assertEqual(alignment.target.annotations["length"], 5190)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 99)
            self.assertEqual(alignment.target.annotations["end"], 351)
            self.assertEqual(
                alignment.target.seq,
                "VKHTSDKALEILKTCHSNLDLKRHPDFIIPLIKACSSKSAKLTTIAMQCLQRMSSVDCIPDSRISQVLDSFIEATLLASDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27)
            self.assertAlmostEqual(alignment.annotations["bit score"], 127)
            self.assertAlmostEqual(alignment.score, 271)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 59.52)
            self.assertEqual(alignment.annotations["identical"], 50)
            self.assertEqual(alignment.annotations["mismatches"], 34)
            self.assertEqual(alignment.annotations["positives"], 69)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 82.14)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071380")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 82)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [350, 295]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|444314872|ref|XM_004178046.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|444314872|ref|XM_004178046.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "444314872")
            self.assertEqual(alignment.target.annotations["gis"], "444314872")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004178046.1")
            self.assertEqual(alignment.target.annotations["length"], 5190)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 186)
            self.assertEqual(alignment.target.annotations["start"], 352)
            self.assertEqual(alignment.target.annotations["end"], 189)
            self.assertEqual(
                alignment.target.seq,
                "TFS*ISEANRVASMKESNT*DILESGIQSTDDILCKHCIAIVVNLALFELHAFIK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 48.7)
            self.assertAlmostEqual(alignment.score, 100)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 50.91)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 56.36)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071380")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 82)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  25],
                                 [137, 112]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|444314872|ref|XM_004178046.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|444314872|ref|XM_004178046.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "444314872")
            self.assertEqual(alignment.target.annotations["gis"], "444314872")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004178046.1")
            self.assertEqual(alignment.target.annotations["length"], 5190)
            self.assertEqual(alignment.query.annotations["start"], 136)
            self.assertEqual(alignment.query.annotations["end"], 63)
            self.assertEqual(alignment.target.annotations["start"], 139)
            self.assertEqual(alignment.target.annotations["end"], 66)
            self.assertEqual(alignment.target.seq, "VLRISKALSLVCLTSEFFLLDSETK")
            self.assertEqual(alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDK")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 23.5)
            self.assertAlmostEqual(alignment.score, 45)
            self.assertEqual(alignment.shape, (2, 25))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.00)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 13)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071380")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 82)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 21)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  60],
                                 [252, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|444314872|ref|XM_004178046.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|444314872|ref|XM_004178046.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "444314872")
            self.assertEqual(alignment.target.annotations["gis"], "444314872")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004178046")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004178046.1")
            self.assertEqual(alignment.target.annotations["length"], 5190)
            self.assertEqual(alignment.query.annotations["start"], 251)
            self.assertEqual(alignment.query.annotations["end"], 73)
            self.assertEqual(alignment.target.annotations["start"], 254)
            self.assertEqual(alignment.target.annotations["end"], 76)
            self.assertEqual(
                alignment.target.seq,
                "SL*ALHCDSSQFGTLRTTCFYQRYYEIRVTF*IQIAMACLKDLQSFITCMFNF*IFSSGF",
            )
            self.assertEqual(
                alignment.query.seq,
                "SL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRF",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.075)
            self.assertAlmostEqual(alignment.annotations["bit score"], 41.4)
            self.assertAlmostEqual(alignment.score, 84)
            self.assertEqual(alignment.shape, (2, 60))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.67)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 31)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071380")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora blattae CBS 6284 hypothetical protein (TBLA0A07860) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 82)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 51)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "VKHASDKSLQILRIVHSFQELERHPDFVHPFVLSCKSGNAKFTTLSMQCLQRLAIHRSISKEQIEPVLEALIDSTQLAVEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27)
            self.assertAlmostEqual(alignment.annotations["bit score"], 127)
            self.assertAlmostEqual(alignment.score, 271)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 60.71)
            self.assertEqual(alignment.annotations["identical"], 51)
            self.assertEqual(alignment.annotations["mismatches"], 33)
            self.assertEqual(alignment.annotations["positives"], 69)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 82.14)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [350, 295]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 186)
            self.assertEqual(alignment.target.annotations["start"], 346)
            self.assertEqual(alignment.target.annotations["end"], 183)
            self.assertEqual(
                alignment.target.seq,
                "TFNWISTAN*VESINASKTGSICSLEIDLWIANRCKHCIERVVNLAFPDLHDNTK",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08)
            self.assertAlmostEqual(alignment.annotations["bit score"], 52.4)
            self.assertAlmostEqual(alignment.score, 108)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 50.91)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 32)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.18)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  25],
                                 [140, 115]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 139)
            self.assertEqual(alignment.query.annotations["end"], 66)
            self.assertEqual(alignment.target.annotations["start"], 136)
            self.assertEqual(alignment.target.annotations["end"], 63)
            self.assertEqual(alignment.target.seq, "TILKI*SDLSDACLTSEFLLLDSED")
            self.assertEqual(alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSED")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08)
            self.assertAlmostEqual(alignment.annotations["bit score"], 27.2)
            self.assertAlmostEqual(alignment.score, 53)
            self.assertEqual(alignment.shape, (2, 25))
            self.assertAlmostEqual(alignment.annotations["% identity"], 56.00)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 11)
            self.assertEqual(alignment.annotations["positives"], 15)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 21)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  72],
                                 [255, 183]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 254)
            self.assertEqual(alignment.query.annotations["end"], 40)
            self.assertEqual(alignment.target.annotations["start"], 251)
            self.assertEqual(alignment.target.annotations["end"], 37)
            self.assertEqual(
                alignment.target.seq,
                "QSLQTLHRKSSKFSIS*FT**YKRVYKIGMSFQFLKTMNYS*DLKRFIRCMFNLRISSFGFRRQRIQILIQL",
            )
            self.assertEqual(
                alignment.query.seq,
                "QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 72))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 32)
            self.assertEqual(alignment.annotations["mismatches"], 40)
            self.assertEqual(alignment.annotations["positives"], 37)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.39)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 62)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  50],
                                 [217, 167]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 216)
            self.assertEqual(alignment.query.annotations["end"], 68)
            self.assertEqual(alignment.target.annotations["start"], 213)
            self.assertEqual(alignment.target.annotations["end"], 65)
            self.assertEqual(
                alignment.target.seq,
                "*HFLIYMIIQKGVQNRDVVPIPENYELFLRFEAIYQMHV*PQNFFFWIQK",
            )
            self.assertEqual(
                alignment.query.seq,
                "*HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.021)
            self.assertAlmostEqual(alignment.annotations["bit score"], 43.2)
            self.assertAlmostEqual(alignment.score, 88)
            self.assertEqual(alignment.shape, (2, 50))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.00)
            self.assertEqual(alignment.annotations["identical"], 24)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-3")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 43)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  69],
                                 [ 65, 134]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363751207|ref|XM_003645773.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363751207|ref|XM_003645773.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363751207")
            self.assertEqual(alignment.target.annotations["gis"], "363751207")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003645773")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003645773.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 65)
            self.assertEqual(alignment.query.annotations["end"], 272)
            self.assertEqual(alignment.target.annotations["start"], 62)
            self.assertEqual(alignment.target.annotations["end"], 269)
            self.assertEqual(
                alignment.target.seq,
                "VF*IQKKKF*G*TCI**IASNLKNSS*FSGIGTTSRFCTPFCIIM*IRKC*IYYSFYAMFAAIGNPQIY",
            )
            self.assertEqual(
                alignment.query.seq,
                "IFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIY",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.27)
            self.assertAlmostEqual(alignment.annotations["bit score"], 39.6)
            self.assertAlmostEqual(alignment.score, 80)
            self.assertEqual(alignment.shape, (2, 69))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.58)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 41)
            self.assertEqual(alignment.annotations["positives"], 38)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "3/3")
            self.assertEqual(alignment.query.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "931890")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Eremothecium cymbalariae DBVPG#7215 hypothetical protein (Ecym_3526) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 89)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 59)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366997674|ref|XM_003683526.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366997674|ref|XM_003683526.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366997674")
            self.assertEqual(alignment.target.annotations["gis"], "366997674")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003683526.1")
            self.assertEqual(alignment.target.annotations["length"], 4890)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 99)
            self.assertEqual(alignment.target.annotations["end"], 351)
            self.assertEqual(
                alignment.target.seq,
                "IHQASDKSIEILKTVKSIDELRRHPDFILPFIIATSSGNAKLTSIALQCIQRFLTVEYIPKSQLGALLDSFISATHLADEIKLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-26)
            self.assertAlmostEqual(alignment.annotations["bit score"], 123)
            self.assertAlmostEqual(alignment.score, 263)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 61.90)
            self.assertEqual(alignment.annotations["identical"], 52)
            self.assertEqual(alignment.annotations["mismatches"], 32)
            self.assertEqual(alignment.annotations["positives"], 65)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 77.38)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071381")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  54],
                                 [175, 121]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366997674|ref|XM_003683526.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366997674|ref|XM_003683526.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366997674")
            self.assertEqual(alignment.target.annotations["gis"], "366997674")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003683526.1")
            self.assertEqual(alignment.target.annotations["length"], 4890)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 14)
            self.assertEqual(alignment.target.annotations["start"], 177)
            self.assertEqual(alignment.target.annotations["end"], 17)
            self.assertEqual(
                alignment.target.seq,
                "NQDVFSIHQLT*LFSKFQWTYH*LDESHCLFFLIRLIKDPSLIIVIF*KPRRLQ",
            )
            self.assertEqual(
                alignment.query.seq,
                "NPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAFAWSQTLQ",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.0)
            self.assertAlmostEqual(alignment.score, 81)
            self.assertEqual(alignment.shape, (2, 54))
            self.assertAlmostEqual(alignment.annotations["% identity"], 46.30)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 29)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.85)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-3")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071381")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 46)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  46],
                                 [350, 304]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366997674|ref|XM_003683526.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366997674|ref|XM_003683526.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366997674")
            self.assertEqual(alignment.target.annotations["gis"], "366997674")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003683526.1")
            self.assertEqual(alignment.target.annotations["length"], 4890)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 213)
            self.assertEqual(alignment.target.annotations["start"], 352)
            self.assertEqual(alignment.target.annotations["end"], 216)
            self.assertEqual(
                alignment.target.seq, "TFNFISSAKWVAEIKESSKAPN*LLGIYSTVKNLCIHCKAILVNFA"
            )
            self.assertEqual(
                alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILA"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 46))
            self.assertAlmostEqual(alignment.annotations["% identity"], 45.65)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 25)
            self.assertEqual(alignment.annotations["positives"], 27)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.70)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071381")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 39)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  91],
                                 [327, 236]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366997674|ref|XM_003683526.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366997674|ref|XM_003683526.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366997674")
            self.assertEqual(alignment.target.annotations["gis"], "366997674")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003683526.1")
            self.assertEqual(alignment.target.annotations["length"], 4890)
            self.assertEqual(alignment.query.annotations["start"], 326)
            self.assertEqual(alignment.query.annotations["end"], 55)
            self.assertEqual(alignment.target.annotations["start"], 329)
            self.assertEqual(alignment.target.annotations["end"], 58)
            self.assertEqual(
                alignment.target.seq,
                "QMGS*NKRV*QSAQLTLRNIFNS*KSLYTLQSNTC*FCITRRGSNYKWQYKIRMSSQFIN*LNCFQNFNGLITSLMNLIVSSF*FV**KTQ",
            )
            self.assertEqual(
                alignment.query.seq,
                "EMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQ",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.001)
            self.assertAlmostEqual(alignment.annotations["bit score"], 47.3)
            self.assertAlmostEqual(alignment.score, 97)
            self.assertEqual(alignment.shape, (2, 91))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.26)
            self.assertEqual(alignment.annotations["identical"], 33)
            self.assertEqual(alignment.annotations["mismatches"], 58)
            self.assertEqual(alignment.annotations["positives"], 47)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 51.65)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071381")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 78)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 42],
                                 [49, 91]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|366997674|ref|XM_003683526.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|366997674|ref|XM_003683526.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "366997674")
            self.assertEqual(alignment.target.annotations["gis"], "366997674")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003683526")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003683526.1")
            self.assertEqual(alignment.target.annotations["length"], 4890)
            self.assertEqual(alignment.query.annotations["start"], 49)
            self.assertEqual(alignment.query.annotations["end"], 175)
            self.assertEqual(alignment.target.annotations["start"], 52)
            self.assertEqual(alignment.target.annotations["end"], 178)
            self.assertEqual(
                alignment.target.seq, "QTWVFYQTNQKEETMRFIKLVISPLKF*KQLSQLMN*EDILI"
            )
            self.assertEqual(
                alignment.query.seq, "QNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRI"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.075)
            self.assertAlmostEqual(alignment.annotations["bit score"], 41.4)
            self.assertAlmostEqual(alignment.score, 84)
            self.assertEqual(alignment.shape, (2, 42))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.62)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 27)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.29)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "1071381")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tetrapisispora phaffii CBS 4417 hypothetical protein (TPHA0A00550) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 96)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 36)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|367014048|ref|XM_003681476.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|367014048|ref|XM_003681476.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "367014048")
            self.assertEqual(alignment.target.annotations["gis"], "367014048")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003681476.1")
            self.assertEqual(alignment.target.annotations["length"], 4902)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 96)
            self.assertEqual(alignment.target.annotations["end"], 348)
            self.assertEqual(
                alignment.target.seq,
                "IKQASDKSIEILRTVRNYEELSNRSEFLAPFLMSCSSKNAKLTSISMQCLQRLSSTPSLSKDKLSDVLEAFIVATQLALDMKLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-24)
            self.assertAlmostEqual(alignment.annotations["bit score"], 115)
            self.assertAlmostEqual(alignment.score, 246)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 52.38)
            self.assertEqual(alignment.annotations["identical"], 44)
            self.assertEqual(alignment.annotations["mismatches"], 40)
            self.assertEqual(alignment.annotations["positives"], 68)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 80.95)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "4950")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  51],
                                 [350, 299]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|367014048|ref|XM_003681476.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|367014048|ref|XM_003681476.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "367014048")
            self.assertEqual(alignment.target.annotations["gis"], "367014048")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003681476.1")
            self.assertEqual(alignment.target.annotations["length"], 4902)
            self.assertEqual(alignment.query.annotations["start"], 349)
            self.assertEqual(alignment.query.annotations["end"], 198)
            self.assertEqual(alignment.target.annotations["start"], 349)
            self.assertEqual(alignment.target.annotations["end"], 198)
            self.assertEqual(
                alignment.target.seq,
                "TFNFMSRAN*VATMNASRTSDNLSFDRDGVDDNLCKHCIDIDVNLAFFEEQ",
            )
            self.assertEqual(
                alignment.query.seq,
                "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQ",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 48.3)
            self.assertAlmostEqual(alignment.score, 99)
            self.assertEqual(alignment.shape, (2, 51))
            self.assertAlmostEqual(alignment.annotations["% identity"], 49.02)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 32)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.75)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "4950")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 44)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  35],
                                 [140, 105]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|367014048|ref|XM_003681476.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|367014048|ref|XM_003681476.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "367014048")
            self.assertEqual(alignment.target.annotations["gis"], "367014048")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003681476")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003681476.1")
            self.assertEqual(alignment.target.annotations["length"], 4902)
            self.assertEqual(alignment.query.annotations["start"], 139)
            self.assertEqual(alignment.query.annotations["end"], 36)
            self.assertEqual(alignment.target.annotations["start"], 139)
            self.assertEqual(alignment.target.annotations["end"], 36)
            self.assertEqual(
                alignment.target.seq, "TVLRISIDLSLACLMAELLFFASEDKSCNSEFNCL"
            )
            self.assertEqual(alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 43.7)
            self.assertAlmostEqual(alignment.score, 89)
            self.assertEqual(alignment.shape, (2, 35))
            self.assertAlmostEqual(alignment.annotations["% identity"], 57.14)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.71)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "4950")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Torulaspora delbrueckii hypothetical protein (TDEL0E00700) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 90)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 30)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  84],
                                 [ 96, 180]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50302786|ref|XM_451330.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50302786|ref|XM_451330.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50302786")
            self.assertEqual(alignment.target.annotations["gis"], "50302786")
            self.assertEqual(alignment.target.annotations["acc."], "XM_451330")
            self.assertEqual(alignment.target.annotations["accs."], "XM_451330")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_451330.1")
            self.assertEqual(alignment.target.annotations["length"], 4809)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 93)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "IKQACEKSIEILQRSHSEEELVRHPDFVDPFITACLSGNAKLTSISMQSMQRISGIRCICTSKMESLLNALLKSTELAIDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-20)
            self.assertAlmostEqual(alignment.annotations["bit score"], 103)
            self.assertAlmostEqual(alignment.score, 219)
            self.assertEqual(alignment.shape, (2, 84))
            self.assertAlmostEqual(alignment.annotations["% identity"], 51.19)
            self.assertEqual(alignment.annotations["identical"], 43)
            self.assertEqual(alignment.annotations["mismatches"], 41)
            self.assertEqual(alignment.annotations["positives"], 63)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 75.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284590")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Kluyveromyces lactis NRRL Y-1140 hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Kluyveromyces lactis NRRL Y-1140 hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 72)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 72)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|367029360|ref|XM_003663916.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|367029360|ref|XM_003663916.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "367029360")
            self.assertEqual(alignment.target.annotations["gis"], "367029360")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003663916")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003663916")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003663916.1")
            self.assertEqual(alignment.target.annotations["length"], 5145)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "KNLRASTEVQASEELAQRPNFVNPFIIACGTKNVKFTGIAIVCLQRLIVSRALPRARLSQVLEALQQATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-13)
            self.assertAlmostEqual(alignment.annotations["bit score"], 79.9)
            self.assertAlmostEqual(alignment.score, 168)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 39.74)
            self.assertEqual(alignment.annotations["identical"], 31)
            self.assertEqual(alignment.annotations["mismatches"], 47)
            self.assertEqual(alignment.annotations["positives"], 52)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "573729")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Myceliophthora thermophila ATCC 42464 hypothetical protein (MYCTH_2139484) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Myceliophthora thermophila ATCC 42464 hypothetical protein (MYCTH_2139484) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|367039842|ref|XM_003650254.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|367039842|ref|XM_003650254.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "367039842")
            self.assertEqual(alignment.target.annotations["gis"], "367039842")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003650254")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003650254")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003650254.1")
            self.assertEqual(alignment.target.annotations["length"], 5163)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "KSLRASSEPQFADELAQRPNFVNPFIIACGTKNSKFTGIAIVCLQRLIIARAFPRSKLSQILDALQQATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-13)
            self.assertAlmostEqual(alignment.annotations["bit score"], 78.5)
            self.assertAlmostEqual(alignment.score, 165)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.03)
            self.assertEqual(alignment.annotations["identical"], 32)
            self.assertEqual(alignment.annotations["mismatches"], 46)
            self.assertEqual(alignment.annotations["positives"], 50)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.10)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "578455")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Thielavia terrestris NRRL 8126 hypothetical protein (THITE_2039383) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Thielavia terrestris NRRL 8126 hypothetical protein (THITE_2039383) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  66],
                                 [150, 216]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302895812|ref|XM_003046741.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302895812|ref|XM_003046741.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302895812")
            self.assertEqual(alignment.target.annotations["gis"], "302895812")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003046741")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003046741")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003046741.1")
            self.assertEqual(alignment.target.annotations["length"], 4878)
            self.assertEqual(alignment.query.annotations["start"], 150)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 141)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "EELSQKVNFVNPFIIACGTKNAKFTAIAIVCLQRLIVAQALPRSKLNQVLEALMQATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "EELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-12)
            self.assertAlmostEqual(alignment.annotations["bit score"], 77.1)
            self.assertAlmostEqual(alignment.score, 162)
            self.assertEqual(alignment.shape, (2, 66))
            self.assertAlmostEqual(alignment.annotations["% identity"], 42.42)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 48)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 72.73)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "660122")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nectria haematococca mpVI 77-13-4 hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nectria haematococca mpVI 77-13-4 hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 57)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 57)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302403860|ref|XM_002999723.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302403860|ref|XM_002999723.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302403860")
            self.assertEqual(alignment.target.annotations["gis"], "302403860")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002999723")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002999723")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002999723.1")
            self.assertEqual(alignment.target.annotations["length"], 5097)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 150)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "ELTQRPNFVNPFVIACGTKNTKFTAIAIVCLQRLILVRALPRGKLSHVLEALREATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-12)
            self.assertAlmostEqual(alignment.annotations["bit score"], 76.7)
            self.assertAlmostEqual(alignment.score, 161)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 46.15)
            self.assertEqual(alignment.annotations["identical"], 30)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 45)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 69.23)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "526221")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Verticillium albo-atrum VaMs.102 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Verticillium albo-atrum VaMs.102 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|154323271|ref|XM_001560900.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|154323271|ref|XM_001560900.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "154323271")
            self.assertEqual(alignment.target.annotations["gis"], "154323271")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001560900")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001560900")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001560900.1")
            self.assertEqual(alignment.target.annotations["length"], 3186)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 141)
            self.assertEqual(alignment.target.annotations["end"], 336)
            self.assertEqual(
                alignment.target.seq,
                "DLTQRPNFVTPFLIACGTRNVKFTGIAVVCLQRLVVSRALPKSRLKEVLEALREATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-12)
            self.assertAlmostEqual(alignment.annotations["bit score"], 75.3)
            self.assertAlmostEqual(alignment.score, 158)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.62)
            self.assertEqual(alignment.annotations["identical"], 29)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 45)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 69.23)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "332648")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Botryotinia fuckeliana B05.10 hypothetical protein (BC1G_00035) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Botryotinia fuckeliana B05.10 hypothetical protein (BC1G_00035) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|389631003|ref|XM_003713107.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|389631003|ref|XM_003713107.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "389631003")
            self.assertEqual(alignment.target.annotations["gis"], "389631003")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003713107")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003713107")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003713107.1")
            self.assertEqual(alignment.target.annotations["length"], 5566)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 293)
            self.assertEqual(alignment.target.annotations["end"], 527)
            self.assertEqual(
                alignment.target.seq,
                "KSLNISSEAQLGPELTQKTNFANPFIIACGTKNAKFTGIAIVCLQRLIVSKALPRPRLNQVLEALQGATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 73.5)
            self.assertAlmostEqual(alignment.score, 154)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 39.74)
            self.assertEqual(alignment.annotations["identical"], 31)
            self.assertEqual(alignment.annotations["mismatches"], 47)
            self.assertEqual(alignment.annotations["positives"], 49)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.82)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "242507")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Magnaporthe oryzae 70-15 hypothetical protein (MGG_07913) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Magnaporthe oryzae 70-15 hypothetical protein (MGG_07913) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|336276565|ref|XM_003352988.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|336276565|ref|XM_003352988.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "336276565")
            self.assertEqual(alignment.target.annotations["gis"], "336276565")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003352988")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003352988")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003352988.1")
            self.assertEqual(alignment.target.annotations["length"], 5166)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "KSLKVTSEAQISAELSQRSNFVNPFIIACGTKNVKFTGIAIVCLQRLIASRALPRFKLSQVLEALQQATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 72.5)
            self.assertAlmostEqual(alignment.score, 152)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.90)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 50)
            self.assertEqual(alignment.annotations["positives"], 49)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.82)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "771870")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Sordaria macrospora k-hell hypothetical protein (SMAC_03354), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Sordaria macrospora k-hell hypothetical protein (SMAC_03354), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|164425502|ref|XM_955020.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|164425502|ref|XM_955020.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "164425502")
            self.assertEqual(alignment.target.annotations["gis"], "164425502")
            self.assertEqual(alignment.target.annotations["acc."], "XM_955020")
            self.assertEqual(alignment.target.annotations["accs."], "XM_955020")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_955020.2")
            self.assertEqual(alignment.target.annotations["length"], 5253)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "KSLKVTSEAQISAELSQRSNFVNPFIIACGTKNVKFTGIAIVCLQRLIASRALPRFKLSQVLEALQQATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 72.5)
            self.assertAlmostEqual(alignment.score, 152)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.90)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 50)
            self.assertEqual(alignment.annotations["positives"], 49)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.82)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "367110")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Neurospora crassa OR74A hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Neurospora crassa OR74A hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296807956|ref|XM_002844271.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|296807956|ref|XM_002844271.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "296807956")
            self.assertEqual(alignment.target.annotations["gis"], "296807956")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002844271")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002844271")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002844271.1")
            self.assertEqual(alignment.target.annotations["length"], 5127)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLARKPQFARPFVLACQTRHTRLAAIGVANLQRLVTIGALPQERLKDVLQGLHETANLSLEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 71.6)
            self.assertAlmostEqual(alignment.score, 150)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 44)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "554155")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Arthroderma otae CBS 113480 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Arthroderma otae CBS 113480 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|327295565|ref|XM_003232430.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|327295565|ref|XM_003232430.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "327295565")
            self.assertEqual(alignment.target.annotations["gis"], "327295565")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003232430")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003232430")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003232430.1")
            self.assertEqual(alignment.target.annotations["length"], 5157)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLARKPQFARPFVLACQTRHTRLAAIGVTNLQRLVTIGALPHERLKDVLQGLHETANLSLEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
            self.assertAlmostEqual(alignment.score, 149)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559305")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Trichophyton rubrum CBS 118892 hypothetical protein (TERG_07323) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Trichophyton rubrum CBS 118892 hypothetical protein (TERG_07323) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|317026200|ref|XM_001389120.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|317026200|ref|XM_001389120.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "317026200")
            self.assertEqual(alignment.target.annotations["gis"], "317026200")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001389120")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001389120")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001389120.2")
            self.assertEqual(alignment.target.annotations["length"], 5229)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPKFANPFILACHSRHAKLAGIGVVCLQRLVASRSLPSERLKDVLAGLKETTNMSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
            self.assertAlmostEqual(alignment.score, 149)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.62)
            self.assertEqual(alignment.annotations["identical"], 29)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "425011")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus niger CBS 513.88 endosomal peripheral membrane protein (Mon2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus niger CBS 513.88 endosomal peripheral membrane protein (Mon2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156058004|ref|XM_001594876.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156058004|ref|XM_001594876.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156058004")
            self.assertEqual(alignment.target.annotations["gis"], "156058004")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001594876")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001594876")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001594876.1")
            self.assertEqual(alignment.target.annotations["length"], 4755)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLTQRANFVTPFLIACGTKNVKFTGIAVVCLQRLVVSRALPRSRLREVLEALREATSAGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
            self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
            self.assertAlmostEqual(alignment.score, 149)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 44)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "665079")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Sclerotinia sclerotiorum 1980 hypothetical protein (SS1G_04734) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Sclerotinia sclerotiorum 1980 hypothetical protein (SS1G_04734) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|315042717|ref|XM_003170687.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|315042717|ref|XM_003170687.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "315042717")
            self.assertEqual(alignment.target.annotations["gis"], "315042717")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003170687")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003170687")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003170687.1")
            self.assertEqual(alignment.target.annotations["length"], 5178)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLARKPQFSRPFVLACQTRHARLAAIGVANLQRLVTIGALPHERLKDVVQGLHETANLSLEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 70.3)
            self.assertAlmostEqual(alignment.score, 147)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.54)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 44)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "535722")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Arthroderma gypseum CBS 118893 hypothetical protein (MGYG_06723) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Arthroderma gypseum CBS 118893 hypothetical protein (MGYG_06723) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|255947577|ref|XM_002564510.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|255947577|ref|XM_002564510.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "255947577")
            self.assertEqual(alignment.target.annotations["gis"], "255947577")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002564510")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002564510")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002564510.1")
            self.assertEqual(alignment.target.annotations["length"], 5004)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPNFVEPFIIACHTRHAKLAGIGVICLQRLIASRSLPSSRLKDVLGGLKETTSLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 69.8)
            self.assertAlmostEqual(alignment.score, 146)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "500485")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Penicillium chrysogenum Wisconsin 54-1255 hypothetical protein (Pc22g05210) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Penicillium chrysogenum Wisconsin 54-1255 hypothetical protein (Pc22g05210) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|121708212|ref|XM_001272061.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|121708212|ref|XM_001272061.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "121708212")
            self.assertEqual(alignment.target.annotations["gis"], "121708212")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001272061")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001272061")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001272061.1")
            self.assertEqual(alignment.target.annotations["length"], 5226)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 150)
            self.assertEqual(alignment.target.annotations["end"], 345)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPKFVDPFILACHSRHAKLSGIGVVCLQRLVASRSLPSSRLKDVLGGLRETTSLNLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 69.8)
            self.assertAlmostEqual(alignment.score, 146)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.62)
            self.assertEqual(alignment.annotations["identical"], 29)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.62)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "344612")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus clavatus NRRL 1 conserved hypothetical protein (ACLA_051080), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus clavatus NRRL 1 conserved hypothetical protein (ACLA_051080), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|303311206|ref|XM_003065569.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|303311206|ref|XM_003065569.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "303311206")
            self.assertEqual(alignment.target.annotations["gis"], "303311206")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003065569")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003065569")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003065569.1")
            self.assertEqual(alignment.target.annotations["length"], 5588)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 289)
            self.assertEqual(alignment.target.annotations["end"], 523)
            self.assertEqual(
                alignment.target.seq,
                "KAVPSTSEVQLAADLVRRPQFANPFILACHTRHAKLAAVGVGCIHRLVASGALPSEQLKDVVDGLHETTNLSLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 69.3)
            self.assertAlmostEqual(alignment.score, 145)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.33)
            self.assertEqual(alignment.annotations["identical"], 26)
            self.assertEqual(alignment.annotations["mismatches"], 52)
            self.assertEqual(alignment.annotations["positives"], 47)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.26)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "222929")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Coccidioides posadasii C735 delta SOWgp HEAT repeat containing protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Coccidioides posadasii C735 delta SOWgp HEAT repeat containing protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|70993553|ref|XM_746531.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|70993553|ref|XM_746531.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "70993553")
            self.assertEqual(alignment.target.annotations["gis"], "70993553")
            self.assertEqual(alignment.target.annotations["acc."], "XM_746531")
            self.assertEqual(alignment.target.annotations["accs."], "XM_746531")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_746531.1")
            self.assertEqual(alignment.target.annotations["length"], 5067)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 45)
            self.assertEqual(alignment.target.annotations["end"], 240)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPKFVDPFILACHSRHAKLAGIGVVCLQRLVASRSLPSERLKDVLGGLKETTSLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 69.3)
            self.assertAlmostEqual(alignment.score, 145)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.62)
            self.assertEqual(alignment.annotations["identical"], 29)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.08)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "330879")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus fumigatus Af293 endosomal peripheral membrane protein (Mon2) (AFUA_4G12070), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus fumigatus Af293 endosomal peripheral membrane protein (Mon2) (AFUA_4G12070), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|212542406|ref|XM_002151322.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|212542406|ref|XM_002151322.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "212542406")
            self.assertEqual(alignment.target.annotations["gis"], "212542406")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002151322")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002151322")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002151322.1")
            self.assertEqual(alignment.target.annotations["length"], 5214)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLIRRPHFVTPFILACQTRQSKLASIGVVCLQRLATSHAISPSRLNDTLSALGDITGLSQDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
            self.assertAlmostEqual(alignment.score, 144)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 44)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "441960")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Penicillium marneffei ATCC 18224 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Penicillium marneffei ATCC 18224 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|119500139|ref|XM_001266826.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|119500139|ref|XM_001266826.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "119500139")
            self.assertEqual(alignment.target.annotations["gis"], "119500139")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001266826")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001266826")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001266826.1")
            self.assertEqual(alignment.target.annotations["length"], 4884)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 45)
            self.assertEqual(alignment.target.annotations["end"], 240)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPRFVDPFILACHSRHAKLAGIGVVCLQRLVASRSLPSERLKDVLGGLKETTSLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
            self.assertAlmostEqual(alignment.score, 144)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.62)
            self.assertEqual(alignment.annotations["identical"], 29)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.08)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "331117")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Neosartorya fischeri NRRL 181 conserved hypothetical protein (NFIA_104180) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Neosartorya fischeri NRRL 181 conserved hypothetical protein (NFIA_104180) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|119194522|ref|XM_001247864.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|119194522|ref|XM_001247864.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "119194522")
            self.assertEqual(alignment.target.annotations["gis"], "119194522")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001247864")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001247864")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001247864.1")
            self.assertEqual(alignment.target.annotations["length"], 5163)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "KALPSTSEVQLAADLVRRPQFANPFILACHTRHAKLAAVGVGCIHRLVASGALPSEQLKDVVDGLHETTNLSLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
            self.assertAlmostEqual(alignment.score, 144)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 33.33)
            self.assertEqual(alignment.annotations["identical"], 26)
            self.assertEqual(alignment.annotations["mismatches"], 52)
            self.assertEqual(alignment.annotations["positives"], 47)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.26)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "246410")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Coccidioides immitis RS hypothetical protein (CIMG_01636) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Coccidioides immitis RS hypothetical protein (CIMG_01636) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|238486173|ref|XM_002374284.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|238486173|ref|XM_002374284.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "238486173")
            self.assertEqual(alignment.target.annotations["gis"], "238486173")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002374284")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002374284")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002374284.1")
            self.assertEqual(alignment.target.annotations["length"], 5160)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLVRKPKFVDPFILACHTRHAKLAGIGVVCLQRLVASRALPSERLKDVLSGLKETTNLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-10)
            self.assertAlmostEqual(alignment.annotations["bit score"], 68.0)
            self.assertAlmostEqual(alignment.score, 142)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.54)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.62)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "332952")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus flavus NRRL3357 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus flavus NRRL3357 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  66],
                                 [150, 216]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50547540|ref|XM_501240.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50547540|ref|XM_501240.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50547540")
            self.assertEqual(alignment.target.annotations["gis"], "50547540")
            self.assertEqual(alignment.target.annotations["acc."], "XM_501240")
            self.assertEqual(alignment.target.annotations["accs."], "XM_501240")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_501240.1")
            self.assertEqual(alignment.target.annotations["length"], 3855)
            self.assertEqual(alignment.query.annotations["start"], 150)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 117)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(
                alignment.target.seq,
                "QDLKKDEKIAQPLVLACSSRNAKLTAIAVPLIQRLLAISALSDKSIPSVLGALEEATHLGVEIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "EELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 67.0)
            self.assertAlmostEqual(alignment.score, 140)
            self.assertEqual(alignment.shape, (2, 66))
            self.assertAlmostEqual(alignment.annotations["% identity"], 42.42)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.64)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284591")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Yarrowia lipolytica YALI0B22858p (YALI0B22858g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Yarrowia lipolytica YALI0B22858p (YALI0B22858g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 57)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 57)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|242768840|ref|XM_002341608.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|242768840|ref|XM_002341608.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "242768840")
            self.assertEqual(alignment.target.annotations["gis"], "242768840")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002341608")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002341608")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002341608.1")
            self.assertEqual(alignment.target.annotations["length"], 5181)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLIRRPHFVTPFILACQTRQSKLASIGVVCLQRLATSHAISPHRLNDTLSALRDITGLGQDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 66.6)
            self.assertAlmostEqual(alignment.score, 139)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.54)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.62)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "441959")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Talaromyces stipitatus ATCC 10500 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Talaromyces stipitatus ATCC 10500 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|115391062|ref|XM_001213036.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|115391062|ref|XM_001213036.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "115391062")
            self.assertEqual(alignment.target.annotations["gis"], "115391062")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001213036")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001213036")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001213036.1")
            self.assertEqual(alignment.target.annotations["length"], 4971)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLARKPKFVDPFILACHTRHAKLAGIGVVCLQRLVASRALPSERLKDVLAGLKETTSLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 66.6)
            self.assertAlmostEqual(alignment.score, 139)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.54)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 38)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.08)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "341663")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus terreus NIH2624 conserved hypothetical protein (ATEG_03858) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus terreus NIH2624 conserved hypothetical protein (ATEG_03858) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|261194600|ref|XM_002623659.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|261194600|ref|XM_002623659.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "261194600")
            self.assertEqual(alignment.target.annotations["gis"], "261194600")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002623659")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002623659")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002623659.1")
            self.assertEqual(alignment.target.annotations["length"], 5331)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 246)
            self.assertEqual(alignment.target.annotations["end"], 441)
            self.assertEqual(
                alignment.target.seq,
                "DLIRKPQFVKPFVIACQTRHGRLAAIGVVCIQRLVASRALPPELLRDVLDGLHETTNLGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 65.2)
            self.assertAlmostEqual(alignment.score, 136)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.92)
            self.assertEqual(alignment.annotations["identical"], 24)
            self.assertEqual(alignment.annotations["mismatches"], 41)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.08)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559298")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ajellomyces dermatitidis SLH14081 endosomal peripheral membrane protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ajellomyces dermatitidis SLH14081 endosomal peripheral membrane protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|398410919|ref|XM_003856759.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|398410919|ref|XM_003856759.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "398410919")
            self.assertEqual(alignment.target.annotations["gis"], "398410919")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003856759")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003856759")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003856759.1")
            self.assertEqual(alignment.target.annotations["length"], 5061)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "DLSRRPAFIEPFLVACGTRNPKFAGPGIICLQKLVIVRGLPKARLQDALEAFNACTDLGQDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 9e-09)
            self.assertAlmostEqual(alignment.annotations["bit score"], 64.3)
            self.assertAlmostEqual(alignment.score, 134)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 43.08)
            self.assertEqual(alignment.annotations["identical"], 28)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 39)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "336722")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Mycosphaerella graminicola IPO323 hypothetical protein (MYCGRDRAFT_67581) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Mycosphaerella graminicola IPO323 hypothetical protein (MYCGRDRAFT_67581) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  65],
                                 [153, 218]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|295669495|ref|XM_002795250.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|295669495|ref|XM_002795250.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "295669495")
            self.assertEqual(alignment.target.annotations["gis"], "295669495")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002795250")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002795250")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002795250.1")
            self.assertEqual(alignment.target.annotations["length"], 5465)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 344)
            self.assertEqual(alignment.target.annotations["end"], 539)
            self.assertEqual(
                alignment.target.seq,
                "DLLRKPHFVKPFVIACQTRHARLAAIGVVGVQRLVASRALPPERLRDVLNALQETTNLGLDVQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-08)
            self.assertAlmostEqual(alignment.annotations["bit score"], 63.4)
            self.assertAlmostEqual(alignment.score, 132)
            self.assertEqual(alignment.shape, (2, 65))
            self.assertAlmostEqual(alignment.annotations["% identity"], 38.46)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 40)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.15)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "502779")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Paracoccidioides brasiliensis Pb01 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Paracoccidioides brasiliensis Pb01 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 56)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 56)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|50422728|ref|XM_459941.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|50422728|ref|XM_459941.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "50422728")
            self.assertEqual(alignment.target.annotations["gis"], "50422728")
            self.assertEqual(alignment.target.annotations["acc."], "XM_459941")
            self.assertEqual(alignment.target.annotations["accs."], "XM_459941")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_459941.1")
            self.assertEqual(alignment.target.annotations["length"], 4800)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 108)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "KSYQPQEKIHDISQNEIKMDILKPFLISCNTGNAKFATISIPIIHKLIIGEIIPVECLNELLDSLKEATNLATDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 60.6)
            self.assertAlmostEqual(alignment.score, 126)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.62)
            self.assertEqual(alignment.annotations["identical"], 27)
            self.assertEqual(alignment.annotations["mismatches"], 51)
            self.assertEqual(alignment.annotations["positives"], 46)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.97)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "284592")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Debaryomyces hansenii CBS767 DEHA2E14608p (DEHA2E14608g) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Debaryomyces hansenii CBS767 DEHA2E14608p (DEHA2E14608g) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  72],
                                 [132, 204]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|126258058|ref|XM_001387099.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|126258058|ref|XM_001387099.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "126258058")
            self.assertEqual(alignment.target.annotations["gis"], "126258058")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001387099")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001387099")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001387099.1")
            self.assertEqual(alignment.target.annotations["length"], 4755)
            self.assertEqual(alignment.query.annotations["start"], 132)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 126)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "KSIHDITNEQHRQHIIAPFVASCRTGNAKIATIAIPTIHKLIMAGVVPLGSLGSLVDSLMEASHLAVDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "KRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 59.7)
            self.assertAlmostEqual(alignment.score, 124)
            self.assertEqual(alignment.shape, (2, 72))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.94)
            self.assertEqual(alignment.annotations["identical"], 23)
            self.assertEqual(alignment.annotations["mismatches"], 49)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 56.94)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "322104")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Scheffersomyces stipitis CBS 6054 chromosome 1",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Scheffersomyces stipitis CBS 6054 chromosome 1",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 62)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 62)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  59],
                                 [153, 212]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302663055|ref|XM_003023130.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302663055|ref|XM_003023130.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302663055")
            self.assertEqual(alignment.target.annotations["gis"], "302663055")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003023130")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003023130")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003023130.1")
            self.assertEqual(alignment.target.annotations["length"], 5163)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 330)
            self.assertEqual(alignment.target.annotations["start"], 108)
            self.assertEqual(alignment.target.annotations["end"], 285)
            self.assertEqual(
                alignment.target.seq,
                "DLARKPQFARPFVLACQTRQTRLAAIGVTNLQRLVTIGALPHERLKDVLQGLHETANLS",
            )
            self.assertEqual(
                alignment.query.seq,
                "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-07)
            self.assertAlmostEqual(alignment.annotations["bit score"], 59.3)
            self.assertAlmostEqual(alignment.score, 123)
            self.assertEqual(alignment.shape, (2, 59))
            self.assertAlmostEqual(alignment.annotations["% identity"], 38.98)
            self.assertEqual(alignment.annotations["identical"], 23)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 36)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 61.02)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "663202")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Trichophyton verrucosum HKI 0517 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Trichophyton verrucosum HKI 0517 endosomal peripheral membrane protein (Mon2), putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 51)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 51)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [183, 238]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|255728730|ref|XM_002549245.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|255728730|ref|XM_002549245.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "255728730")
            self.assertEqual(alignment.target.annotations["gis"], "255728730")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002549245")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002549245")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002549245.1")
            self.assertEqual(alignment.target.annotations["length"], 4671)
            self.assertEqual(alignment.query.annotations["start"], 183)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 177)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "PFILACKSGNIKLTNTATPVIYKLILAHAIPEENIPELLQALLEASNLAIDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "PFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-06)
            self.assertAlmostEqual(alignment.annotations["bit score"], 57.0)
            self.assertAlmostEqual(alignment.score, 118)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.82)
            self.assertEqual(alignment.annotations["identical"], 23)
            self.assertEqual(alignment.annotations["mismatches"], 32)
            self.assertEqual(alignment.annotations["positives"], 36)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.45)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "294747")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida tropicalis MYA-3404 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida tropicalis MYA-3404 conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  35],
                                 [132, 167]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|171682617|ref|XM_001906217.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|171682617|ref|XM_001906217.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "171682617")
            self.assertEqual(alignment.target.annotations["gis"], "171682617")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001906217")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001906217")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001906217.1")
            self.assertEqual(alignment.target.annotations["length"], 4959)
            self.assertEqual(alignment.query.annotations["start"], 132)
            self.assertEqual(alignment.query.annotations["end"], 237)
            self.assertEqual(alignment.target.annotations["start"], 10)
            self.assertEqual(alignment.target.annotations["end"], 115)
            self.assertEqual(
                alignment.target.seq, "RQTYTIPELTQRPNFVNPFIIACGTKNVKFTGIAI"
            )
            self.assertEqual(alignment.query.seq, "KRVHSFEELERHPDFALPFVLACQSRNAKMTTLAM")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-06)
            self.assertAlmostEqual(alignment.annotations["bit score"], 38.6)
            self.assertAlmostEqual(alignment.score, 78)
            self.assertEqual(alignment.shape, (2, 35))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.29)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 23)
            self.assertEqual(alignment.annotations["positives"], 24)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 68.57)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "515849")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Podospora anserina S mat+ hypothetical protein (PODANSg3280) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Podospora anserina S mat+ hypothetical protein (PODANSg3280) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 52)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 30)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  26],
                                 [270, 296]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|171682617|ref|XM_001906217.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|171682617|ref|XM_001906217.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "171682617")
            self.assertEqual(alignment.target.annotations["gis"], "171682617")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001906217")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001906217")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001906217.1")
            self.assertEqual(alignment.target.annotations["length"], 4959)
            self.assertEqual(alignment.query.annotations["start"], 270)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 117)
            self.assertEqual(alignment.target.annotations["end"], 195)
            self.assertEqual(alignment.target.seq, "LPRSRLSQVLEALQQATSAGLDVQLK")
            self.assertEqual(alignment.query.seq, "IPRSRLSEILDAFIEATHLAMEIQLK")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-06)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 26))
            self.assertAlmostEqual(alignment.annotations["% identity"], 50.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 21)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 80.77)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "515849")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Podospora anserina S mat+ hypothetical protein (PODANSg3280) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Podospora anserina S mat+ hypothetical protein (PODANSg3280) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 52)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 22)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|460402609|ref|XM_004246756.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|460402609|ref|XM_004246756.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "460402609")
            self.assertEqual(alignment.target.annotations["gis"], "460402609")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004246756")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004246756")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004246756.1")
            self.assertEqual(alignment.target.annotations["length"], 5431)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 402)
            self.assertEqual(alignment.target.annotations["end"], 642)
            self.assertEqual(
                alignment.target.seq,
                "VKDAAEHAILKLRSLSSPSEIAHNEDILNIFLMACEVRNVKMSVIGLSCLQKLISHDVVATSALKEILDTLKDHGEMADE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 53.3)
            self.assertAlmostEqual(alignment.score, 110)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.25)
            self.assertEqual(alignment.annotations["identical"], 25)
            self.assertEqual(alignment.annotations["mismatches"], 55)
            self.assertEqual(alignment.annotations["positives"], 44)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "4081")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Solanum lycopersicum protein MON2 homolog (LOC101244609), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Solanum lycopersicum protein MON2 homolog (LOC101244609), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|68467204|ref|XM_717171.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|68467204|ref|XM_717171.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "68467204")
            self.assertEqual(alignment.target.annotations["gis"], "68467204")
            self.assertEqual(alignment.target.annotations["acc."], "XM_717171")
            self.assertEqual(alignment.target.annotations["accs."], "XM_717171")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_717171.1")
            self.assertEqual(alignment.target.annotations["length"], 4905)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 108)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "KSYSLVVPIQEINKEDHKEEILKPFILSCKSGNIKLTNISIPVIHKLILAHLIPELDITQVLLCLLEASNLAVDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 53.3)
            self.assertAlmostEqual(alignment.score, 110)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 26.92)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 57)
            self.assertEqual(alignment.annotations["positives"], 45)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "237561")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida albicans SC5314 hypothetical protein (CaO19_12405) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida albicans SC5314 hypothetical protein (CaO19_12405) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|68467433|ref|XM_717057.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|68467433|ref|XM_717057.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "68467433")
            self.assertEqual(alignment.target.annotations["gis"], "68467433")
            self.assertEqual(alignment.target.annotations["acc."], "XM_717057")
            self.assertEqual(alignment.target.annotations["accs."], "XM_717057")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_717057.1")
            self.assertEqual(alignment.target.annotations["length"], 4905)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 108)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "KSYSLVVPIQEINKEDHKEEILKPFILSCKSGNIKLTNISIPVIHKLILAHLIPELDITQVLLCLLEASNLAVDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 53.3)
            self.assertAlmostEqual(alignment.score, 110)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 26.92)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 57)
            self.assertEqual(alignment.annotations["positives"], 45)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.69)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "237561")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida albicans SC5314 hypothetical protein (MON2) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida albicans SC5314 hypothetical protein (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  51],
                                 [195, 246]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|317144425|ref|XM_001820059.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|317144425|ref|XM_001820059.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "317144425")
            self.assertEqual(alignment.target.annotations["gis"], "317144425")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001820059")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001820059")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001820059.2")
            self.assertEqual(alignment.target.annotations["length"], 5076)
            self.assertEqual(alignment.query.annotations["start"], 195)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 144)
            self.assertEqual(alignment.target.annotations["end"], 297)
            self.assertEqual(
                alignment.target.seq,
                "ACHTRHAKLAGIGVVCLQRLVASRALPSERLKDVLSGLKETTNLSLDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "ACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 51.5)
            self.assertAlmostEqual(alignment.score, 106)
            self.assertEqual(alignment.shape, (2, 51))
            self.assertAlmostEqual(alignment.annotations["% identity"], 39.22)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 31)
            self.assertEqual(alignment.annotations["positives"], 33)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.71)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "510516")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aspergillus oryzae RIB40 endosomal peripheral membrane protein (Mon2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aspergillus oryzae RIB40 endosomal peripheral membrane protein (Mon2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 44)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 44)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [114, 192]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|241950270|ref|XM_002417813.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|241950270|ref|XM_002417813.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "241950270")
            self.assertEqual(alignment.target.annotations["gis"], "241950270")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002417813")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002417813")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002417813.1")
            self.assertEqual(alignment.target.annotations["length"], 4944)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 108)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "KSYSSVVPIQEINKENHREEVLKPFILSCKSGNIKLTNISIPVIYKLILAHLIPELDISQVLLCLLEASNLAVDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 7e-05)
            self.assertAlmostEqual(alignment.annotations["bit score"], 51.5)
            self.assertAlmostEqual(alignment.score, 106)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 28.21)
            self.assertEqual(alignment.annotations["identical"], 22)
            self.assertEqual(alignment.annotations["mismatches"], 56)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.13)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "573826")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Candida dubliniensis CD36 SEC7-family member, endocytosis and vacuole integrity protein, putative (CD36_12180) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Candida dubliniensis CD36 SEC7-family member, endocytosis and vacuole integrity protein, putative (CD36_12180) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [183, 238]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|448082269|ref|XM_004195049.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|448082269|ref|XM_004195049.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "448082269")
            self.assertEqual(alignment.target.annotations["gis"], "448082269")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004195049")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004195049")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004195049.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 183)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 177)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "PFILSSHNWNAKTATISIPIIHKLIISNAVSREDLEQLLHALKEASNLALDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "PFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.55)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 35)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.64)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559304")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 62)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[ 0, 17],
                                 [55, 72]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|448082269|ref|XM_004195049.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|448082269|ref|XM_004195049.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "448082269")
            self.assertEqual(alignment.target.annotations["gis"], "448082269")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004195049")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004195049")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004195049.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 55)
            self.assertEqual(alignment.query.annotations["end"], 106)
            self.assertEqual(alignment.target.annotations["start"], 31)
            self.assertEqual(alignment.target.annotations["end"], 82)
            self.assertEqual(alignment.target.seq, "CIVFSVNRREETPVFVM")
            self.assertEqual(alignment.query.seq, "CVLYLPNRKEEIQPFAM")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 22.1)
            self.assertAlmostEqual(alignment.score, 42)
            self.assertEqual(alignment.shape, (2, 17))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.18)
            self.assertEqual(alignment.annotations["identical"], 7)
            self.assertEqual(alignment.annotations["mismatches"], 10)
            self.assertEqual(alignment.annotations["positives"], 11)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 64.71)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "559304")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 62)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 15)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|359487908|ref|XM_003633625.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|359487908|ref|XM_003633625.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "359487908")
            self.assertEqual(alignment.target.annotations["gis"], "359487908")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003633625")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003633625")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003633625.1")
            self.assertEqual(alignment.target.annotations["length"], 5238)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHGILKLRSLSSPSEIAHNEDILRIFLMACEVRNVKLSVIGLSCLQKLISHDAVAPSALKEILSTLKDHAEMADE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 49.2)
            self.assertAlmostEqual(alignment.score, 101)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.50)
            self.assertEqual(alignment.annotations["identical"], 22)
            self.assertEqual(alignment.annotations["mismatches"], 58)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.50)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "29760")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Vitis vinifera protein MON2 homolog (LOC100264068), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Vitis vinifera protein MON2 homolog (LOC100264068), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  81],
                                 [ 96, 177]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302795299|ref|XM_002979367.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302795299|ref|XM_002979367.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302795299")
            self.assertEqual(alignment.target.annotations["gis"], "302795299")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002979367")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002979367")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002979367.1")
            self.assertEqual(alignment.target.annotations["length"], 5019)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(
                alignment.target.seq,
                "VKDAAEHAILKLRTITDPSQISRNDDVLRLYMLACDTRNVKLSILGLSCLQKLLAHDAVPPLAFPQILETLQEHCEINDEI",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 49.2)
            self.assertAlmostEqual(alignment.score, 101)
            self.assertEqual(alignment.shape, (2, 81))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.16)
            self.assertEqual(alignment.annotations["identical"], 22)
            self.assertEqual(alignment.annotations["mismatches"], 59)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 53.09)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "88036")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  81],
                                 [ 96, 177]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302792279|ref|XM_002977860.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302792279|ref|XM_002977860.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302792279")
            self.assertEqual(alignment.target.annotations["gis"], "302792279")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002977860")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002977860")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002977860.1")
            self.assertEqual(alignment.target.annotations["length"], 5197)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(
                alignment.target.seq,
                "VKDAAEHAILKLRTVTDPSQIARNDDVLRLYMLACDTRNVKLSILGLSCLQKLLAHDAVPPLAFPQILETLQEHCEINDEI",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 49.2)
            self.assertAlmostEqual(alignment.score, 101)
            self.assertEqual(alignment.shape, (2, 81))
            self.assertAlmostEqual(alignment.annotations["% identity"], 28.40)
            self.assertEqual(alignment.annotations["identical"], 23)
            self.assertEqual(alignment.annotations["mismatches"], 58)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 53.09)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "88036")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  57],
                                 [177, 234]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|146416588|ref|XM_001484214.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|146416588|ref|XM_001484214.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "146416588")
            self.assertEqual(alignment.target.annotations["gis"], "146416588")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001484214")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001484214")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001484214.1")
            self.assertEqual(alignment.target.annotations["length"], 1320)
            self.assertEqual(alignment.query.annotations["start"], 177)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 168)
            self.assertEqual(alignment.target.annotations["end"], 339)
            self.assertEqual(
                alignment.target.seq,
                "AAPLVSTLASNNTKLVTISILAINRLAGTTAFSTATLGPLLDGLLEASHLAMDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "ALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 5e-04)
            self.assertAlmostEqual(alignment.annotations["bit score"], 48.7)
            self.assertAlmostEqual(alignment.score, 100)
            self.assertEqual(alignment.shape, (2, 57))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.09)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 33)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.89)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "294746")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Meyerozyma guilliermondii ATCC 6260 hypothetical protein (PGUG_03645) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Meyerozyma guilliermondii ATCC 6260 hypothetical protein (PGUG_03645) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 49)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 49)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|255542393|ref|XM_002512214.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|255542393|ref|XM_002512214.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "255542393")
            self.assertEqual(alignment.target.annotations["gis"], "255542393")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002512214")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002512214")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002512214.1")
            self.assertEqual(alignment.target.annotations["length"], 4776)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSLSSPNEIAHNEDILRIFLMACEVRTVKLSVIGLSCLQKLISHDAVAPSALKEILSTLKDHAEMADE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.002)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.9)
            self.assertAlmostEqual(alignment.score, 96)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 26.25)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 59)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.50)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3988")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ricinus communis guanine nucleotide-exchange, putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ricinus communis guanine nucleotide-exchange, putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470133344|ref|XM_004302479.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470133344|ref|XM_004302479.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470133344")
            self.assertEqual(alignment.target.annotations["gis"], "470133344")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004302479")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004302479")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004302479.1")
            self.assertEqual(alignment.target.annotations["length"], 5152)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSLSSPGEIAQNEDILRIFLMACEVRTVKLSVIGLSCLQKLISHDAVASSALHEILSTLKDHAEMADE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.002)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
            self.assertAlmostEqual(alignment.score, 95)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 26.25)
            self.assertEqual(alignment.annotations["identical"], 21)
            self.assertEqual(alignment.annotations["mismatches"], 59)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 53.75)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "101020")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Fragaria vesca subsp. vesca protein MON2 homolog (LOC101302372), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Fragaria vesca subsp. vesca protein MON2 homolog (LOC101302372), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  69],
                                 [ 93, 162]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|356574903|ref|XM_003555535.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|356574903|ref|XM_003555535.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "356574903")
            self.assertEqual(alignment.target.annotations["gis"], "356574903")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003555535")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003555535")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003555535.1")
            self.assertEqual(alignment.target.annotations["length"], 4935)
            self.assertEqual(alignment.query.annotations["start"], 93)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 69)
            self.assertEqual(alignment.target.annotations["end"], 276)
            self.assertEqual(
                alignment.target.seq,
                "TVKDGAEHAILKLRTLSSPSEIAHNDDILRIFLMACEVRTVKLSVIGLSCLQKLISHDAVSPSALREIL",
            )
            self.assertEqual(
                alignment.query.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.002)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
            self.assertAlmostEqual(alignment.score, 95)
            self.assertEqual(alignment.shape, (2, 69))
            self.assertAlmostEqual(alignment.annotations["% identity"], 28.99)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 49)
            self.assertEqual(alignment.annotations["positives"], 39)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 56.52)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3847")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Glycine max protein MON2 homolog (LOC100777257), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Glycine max protein MON2 homolog (LOC100777257), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 59)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 59)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|334187990|ref|NM_001203485.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|334187990|ref|NM_001203485.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "334187990")
            self.assertEqual(alignment.target.annotations["gis"], "334187990")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001203485")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001203485")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001203485.1")
            self.assertEqual(alignment.target.annotations["length"], 5026)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSSSSASDLSSNEDILRIFLMACGVRNTKLSVIGLSCLQKLISHDAVEPSSLKEILYTLKDHSEMAEE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.002)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
            self.assertAlmostEqual(alignment.score, 95)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.50)
            self.assertEqual(alignment.annotations["identical"], 22)
            self.assertEqual(alignment.annotations["mismatches"], 58)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.50)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3702")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Arabidopsis thaliana armadillo/beta-catenin-like repeat-containing protein (AT5G27970) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Arabidopsis thaliana armadillo/beta-catenin-like repeat-containing protein (AT5G27970) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  78],
                                 [ 96, 174]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|334187988|ref|NM_122680.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|334187988|ref|NM_122680.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "334187988")
            self.assertEqual(alignment.target.annotations["gis"], "334187988")
            self.assertEqual(alignment.target.annotations["acc."], "NM_122680")
            self.assertEqual(alignment.target.annotations["accs."], "NM_122680")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_122680.3")
            self.assertEqual(alignment.target.annotations["length"], 5132)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 330)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 306)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSSSSASDLSSNEDILRIFLMACGVRNTKLSVIGLSCLQKLISHDAVEPSSLKEILYTLKDAKQLS",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.002)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
            self.assertAlmostEqual(alignment.score, 95)
            self.assertEqual(alignment.shape, (2, 78))
            self.assertAlmostEqual(alignment.annotations["% identity"], 28.21)
            self.assertEqual(alignment.annotations["identical"], 22)
            self.assertEqual(alignment.annotations["mismatches"], 56)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.56)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3702")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Arabidopsis thaliana armadillo/beta-catenin-like repeat-containing protein (AT5G27970) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Arabidopsis thaliana armadillo/beta-catenin-like repeat-containing protein (AT5G27970) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 67)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 67)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  74],
                                 [ 96, 170]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|356535140|ref|XM_003536059.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|356535140|ref|XM_003536059.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "356535140")
            self.assertEqual(alignment.target.annotations["gis"], "356535140")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003536059")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003536059")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003536059.1")
            self.assertEqual(alignment.target.annotations["length"], 5612)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 318)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 294)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRTLSSPSEIAHNDDILRIFLMACEVRTVKLSIIGLSCLQKLISHDAVSPSALTEILSTLKDA",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEA",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.003)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.0)
            self.assertAlmostEqual(alignment.score, 94)
            self.assertEqual(alignment.shape, (2, 74))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.03)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 54)
            self.assertEqual(alignment.annotations["positives"], 41)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3847")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Glycine max protein MON2 homolog, transcript variant 2 (LOC100818893), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Glycine max protein MON2 homolog, transcript variant 2 (LOC100818893), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 63)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 63)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  49],
                                 [153, 202]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296414539|ref|XM_002836911.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|296414539|ref|XM_002836911.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "296414539")
            self.assertEqual(alignment.target.annotations["gis"], "296414539")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002836911")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002836911")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002836911.1")
            self.assertEqual(alignment.target.annotations["length"], 5004)
            self.assertEqual(alignment.query.annotations["start"], 153)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 147)
            self.assertEqual(alignment.target.annotations["end"], 294)
            self.assertEqual(
                alignment.target.seq,
                "ELSGRPQFIHPFLIACSTRNAKFSTIGVVCLQRLIVSQGLAKVCRQDIL",
            )
            self.assertEqual(
                alignment.query.seq, "ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.003)
            self.assertAlmostEqual(alignment.annotations["bit score"], 46.0)
            self.assertAlmostEqual(alignment.score, 94)
            self.assertEqual(alignment.shape, (2, 49))
            self.assertAlmostEqual(alignment.annotations["% identity"], 38.78)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 30)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.14)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "656061")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Tuber melanosporum Mel28 hypothetical protein (GSTUM_00003289001) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Tuber melanosporum Mel28 hypothetical protein (GSTUM_00003289001) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 42)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 42)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  82],
                                 [ 93, 175]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|297597693|ref|NM_001050929.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|297597693|ref|NM_001050929.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "297597693")
            self.assertEqual(alignment.target.annotations["gis"], "297597693")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001050929")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001050929")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001050929.2")
            self.assertEqual(alignment.target.annotations["length"], 3804)
            self.assertEqual(alignment.query.annotations["start"], 93)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 69)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(
                alignment.target.seq,
                "SVKDAAEHAILKLRSLSSPMEIAQNEDILRMFLVACSVKSVKLSVIGLSCLQKLISHDAVASSALKDILTTLKDHAEMTDEI",
            )
            self.assertEqual(
                alignment.query.seq,
                "TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.004)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.5)
            self.assertAlmostEqual(alignment.score, 93)
            self.assertEqual(alignment.shape, (2, 82))
            self.assertAlmostEqual(alignment.annotations["% identity"], 24.39)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 62)
            self.assertEqual(alignment.annotations["positives"], 45)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 54.88)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "39947")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Oryza sativa Japonica Group Os01g0772700 (Os01g0772700) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Oryza sativa Japonica Group Os01g0772700 (Os01g0772700) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 70)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 70)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [183, 238]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|448086792|ref|XM_004196143.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|448086792|ref|XM_004196143.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "448086792")
            self.assertEqual(alignment.target.annotations["gis"], "448086792")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004196143")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004196143")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004196143.1")
            self.assertEqual(alignment.target.annotations["length"], 4794)
            self.assertEqual(alignment.query.annotations["start"], 183)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 177)
            self.assertEqual(alignment.target.annotations["end"], 342)
            self.assertEqual(
                alignment.target.seq,
                "PFILSSHNWNAKTATISIPIIHKLIISNAVSREDLEQLLHALKEASNLALDIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "PFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.55)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 36)
            self.assertEqual(alignment.annotations["positives"], 35)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.64)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "559304")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Millerozyma farinosa CBS 7064 hypothetical protein (Piso0_005640) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  59],
                                 [171, 230]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|403176154|ref|XM_003334821.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|403176154|ref|XM_003334821.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "403176154")
            self.assertEqual(alignment.target.annotations["gis"], "403176154")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003334821")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003334821")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003334821.2")
            self.assertEqual(alignment.target.annotations["length"], 5427)
            self.assertEqual(alignment.query.annotations["start"], 171)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 186)
            self.assertEqual(alignment.target.annotations["end"], 363)
            self.assertEqual(
                alignment.target.seq,
                "DIFRPISMACATKNAKVVVIALGSLQRLIAMDAVPSCKIPQIVNLLSTVLPLGVEIQLR",
            )
            self.assertEqual(
                alignment.query.seq,
                "DFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 59))
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.51)
            self.assertEqual(alignment.annotations["identical"], 18)
            self.assertEqual(alignment.annotations["mismatches"], 41)
            self.assertEqual(alignment.annotations["positives"], 34)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.63)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "418459")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Puccinia graminis f. sp. tritici CRL 75-36-700-3 hypothetical protein (PGTG_16037), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Puccinia graminis f. sp. tritici CRL 75-36-700-3 hypothetical protein (PGTG_16037), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 51)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 51)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  80],
                                 [ 96, 176]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|356535138|ref|XM_003536058.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|356535138|ref|XM_003536058.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "356535138")
            self.assertEqual(alignment.target.annotations["gis"], "356535138")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003536058")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003536058")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003536058.1")
            self.assertEqual(alignment.target.annotations["length"], 5530)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 336)
            self.assertEqual(alignment.target.annotations["start"], 152)
            self.assertEqual(alignment.target.annotations["end"], 392)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRTLSSPSEIAHNDDILRIFLMACEVRTVKLSIIGLSCLQKLISHDAVSPSALTEILSTLKDHAEMVDE",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAME",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.006)
            self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
            self.assertAlmostEqual(alignment.score, 92)
            self.assertEqual(alignment.shape, (2, 80))
            self.assertAlmostEqual(alignment.annotations["% identity"], 25.00)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 60)
            self.assertEqual(alignment.annotations["positives"], 42)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.50)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "3847")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Glycine max protein MON2 homolog, transcript variant 1 (LOC100818893), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Glycine max protein MON2 homolog, transcript variant 1 (LOC100818893), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  68],
                                 [ 96, 164]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|297808820|ref|XM_002872248.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|297808820|ref|XM_002872248.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "297808820")
            self.assertEqual(alignment.target.annotations["gis"], "297808820")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002872248")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002872248")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002872248.1")
            self.assertEqual(alignment.target.annotations["length"], 4854)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 276)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSSSSASDLSSNEDILRIFLMACGVRNTKLSVIGLSCLQKLISHDAVEPSSLKEIL",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.008)
            self.assertAlmostEqual(alignment.annotations["bit score"], 44.6)
            self.assertAlmostEqual(alignment.score, 91)
            self.assertEqual(alignment.shape, (2, 68))
            self.assertAlmostEqual(alignment.annotations["% identity"], 29.41)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 48)
            self.assertEqual(alignment.annotations["positives"], 37)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 54.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "81972")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Arabidopsis lyrata subsp. lyrata binding protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Arabidopsis lyrata subsp. lyrata binding protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 58)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 58)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  81],
                                 [ 96, 177]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|242054552|ref|XM_002456377.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|242054552|ref|XM_002456377.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "242054552")
            self.assertEqual(alignment.target.annotations["gis"], "242054552")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002456377")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002456377")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002456377.1")
            self.assertEqual(alignment.target.annotations["length"], 414)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(
                alignment.target.seq,
                "VKDAAEHAVLKLRSLSGPSEIAQNEDILRMFLMACSVKSVKLSVIGLSCLQKLISHGAVASSALKEILATLKDHAEMTDEI",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.008)
            self.assertAlmostEqual(alignment.annotations["bit score"], 44.6)
            self.assertAlmostEqual(alignment.score, 91)
            self.assertEqual(alignment.shape, (2, 81))
            self.assertAlmostEqual(alignment.annotations["% identity"], 23.46)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 62)
            self.assertEqual(alignment.annotations["positives"], 43)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 53.09)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "4558")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Sorghum bicolor hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Sorghum bicolor hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 69)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 69)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  68],
                                 [ 96, 164]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|224125555|ref|XM_002319579.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|224125555|ref|XM_002319579.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "224125555")
            self.assertEqual(alignment.target.annotations["gis"], "224125555")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002319579")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002319579")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002319579.1")
            self.assertEqual(alignment.target.annotations["length"], 4914)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 276)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRSLSSPSEIADNEDILRIFLMACEVRTVKLSVIGLSCLQKLISHDAVAPSALKEIL",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.015)
            self.assertAlmostEqual(alignment.annotations["bit score"], 43.7)
            self.assertAlmostEqual(alignment.score, 89)
            self.assertEqual(alignment.shape, (2, 68))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.94)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 49)
            self.assertEqual(alignment.annotations["positives"], 38)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 55.88)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3694")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Populus trichocarpa predicted protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Populus trichocarpa predicted protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 58)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 58)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  68],
                                 [ 96, 164]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|357131062|ref|XR_138050.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|357131062|ref|XR_138050.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "357131062")
            self.assertEqual(alignment.target.annotations["gis"], "357131062")
            self.assertEqual(alignment.target.annotations["acc."], "XR_138050")
            self.assertEqual(alignment.target.annotations["accs."], "XR_138050")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XR_138050.1")
            self.assertEqual(alignment.target.annotations["length"], 3794)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 276)
            self.assertEqual(
                alignment.target.seq,
                "VKDAAEHATLKLRSLSNPSEIAQNGDILRMFLMACSVKSVKLSAIGLSCLQKLISHDAVASSALKEIL",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.054)
            self.assertAlmostEqual(alignment.annotations["bit score"], 41.8)
            self.assertAlmostEqual(alignment.score, 85)
            self.assertEqual(alignment.shape, (2, 68))
            self.assertAlmostEqual(alignment.annotations["% identity"], 25.00)
            self.assertEqual(alignment.annotations["identical"], 17)
            self.assertEqual(alignment.annotations["mismatches"], 51)
            self.assertEqual(alignment.annotations["positives"], 39)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 57.35)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "15368")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Brachypodium distachyon uncharacterized LOC100838086 (LOC100838086), miscRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Brachypodium distachyon uncharacterized LOC100838086 (LOC100838086), miscRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 58)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 58)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|403290914|ref|XM_003936502.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|403290914|ref|XM_003936502.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "403290914")
            self.assertEqual(alignment.target.annotations["gis"], "403290914")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003936502")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003936502")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003936502.1")
            self.assertEqual(alignment.target.annotations["length"], 7255)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6674)
            self.assertEqual(alignment.target.annotations["end"], 6553)
            self.assertEqual(
                alignment.target.seq, "TLEVSCLQGLHTSPSLEDQGVSQITNAFNMVVHLSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.14)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.5)
            self.assertAlmostEqual(alignment.score, 82)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.46)
            self.assertEqual(alignment.annotations["identical"], 17)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "39432")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Saimiri boliviensis boliviensis Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Saimiri boliviensis boliviensis Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|297707079|ref|XM_002830297.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|297707079|ref|XM_002830297.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "297707079")
            self.assertEqual(alignment.target.annotations["gis"], "297707079")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002830297")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002830297")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002830297.1")
            self.assertEqual(alignment.target.annotations["length"], 8045)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6176)
            self.assertEqual(alignment.target.annotations["end"], 6055)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHTLPSLEDKGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.14)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.5)
            self.assertAlmostEqual(alignment.score, 82)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 39.02)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 25)
            self.assertEqual(alignment.annotations["positives"], 27)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.85)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9601")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pongo abelii Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pongo abelii Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  69],
                                 [105, 174]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|254567673|ref|XM_002490902.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|254567673|ref|XM_002490902.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "254567673")
            self.assertEqual(alignment.target.annotations["gis"], "254567673")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002490902")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002490902")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002490902.1")
            self.assertEqual(alignment.target.annotations["length"], 4647)
            self.assertEqual(alignment.query.annotations["start"], 105)
            self.assertEqual(alignment.query.annotations["end"], 312)
            self.assertEqual(alignment.target.annotations["start"], 87)
            self.assertEqual(alignment.target.annotations["end"], 294)
            self.assertEqual(
                alignment.target.seq,
                "ASIDMIRSFKQRVPIQELVKFESFVDPFLLSIQTRSLKLVNTGLACLQKLIIESAIADTKLESLVNSLL",
            )
            self.assertEqual(
                alignment.query.seq,
                "ASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.19)
            self.assertAlmostEqual(alignment.annotations["bit score"], 40.0)
            self.assertAlmostEqual(alignment.score, 81)
            self.assertEqual(alignment.shape, (2, 69))
            self.assertAlmostEqual(alignment.annotations["% identity"], 27.54)
            self.assertEqual(alignment.annotations["identical"], 19)
            self.assertEqual(alignment.annotations["mismatches"], 50)
            self.assertEqual(alignment.annotations["positives"], 36)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 52.17)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "644223")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pichia pastoris GS115 Peripheral membrane protein with a role in endocytosis and vacuole integrity, interacts with Arl1p a (PAS_chr2-1_0066) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pichia pastoris GS115 Peripheral membrane protein with a role in endocytosis and vacuole integrity, interacts with Arl1p a (PAS_chr2-1_0066) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 59)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 59)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  50],
                                 [189, 239]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|302772536|ref|XM_002969640.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|302772536|ref|XM_002969640.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "302772536")
            self.assertEqual(alignment.target.annotations["gis"], "302772536")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002969640")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002969640")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002969640.1")
            self.assertEqual(alignment.target.annotations["length"], 399)
            self.assertEqual(alignment.query.annotations["start"], 189)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 0)
            self.assertEqual(alignment.target.annotations["end"], 150)
            self.assertEqual(
                alignment.target.seq,
                "MLTCKTRNIKLSVLGLSCLQKLLAHDAIPPLAVPQILEILQEHSEIHYEV",
            )
            self.assertEqual(
                alignment.query.seq,
                "VLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEI",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.27)
            self.assertAlmostEqual(alignment.annotations["bit score"], 39.6)
            self.assertAlmostEqual(alignment.score, 80)
            self.assertEqual(alignment.shape, (2, 50))
            self.assertAlmostEqual(alignment.annotations["% identity"], 32.00)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 34)
            self.assertEqual(alignment.annotations["positives"], 29)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 58.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "88036")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Selaginella moellendorffii hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 43)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 43)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|189235995|ref|XM_967692.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|189235995|ref|XM_967692.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "189235995")
            self.assertEqual(alignment.target.annotations["gis"], "189235995")
            self.assertEqual(alignment.target.annotations["acc."], "XM_967692")
            self.assertEqual(alignment.target.annotations["accs."], "XM_967692")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_967692.2")
            self.assertEqual(alignment.target.annotations["length"], 5169)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 231)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRSARIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.27)
            self.assertAlmostEqual(alignment.annotations["bit score"], 39.6)
            self.assertAlmostEqual(alignment.score, 80)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 55.56)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 12)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7070")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Tribolium castaneum similar to AGAP008906-PA (LOC661541), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Tribolium castaneum similar to AGAP008906-PA (LOC661541), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  52],
                                 [192, 244]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|238586708|ref|XM_002391211.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|238586708|ref|XM_002391211.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "238586708")
            self.assertEqual(alignment.target.annotations["gis"], "238586708")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002391211")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002391211")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002391211.1")
            self.assertEqual(alignment.target.annotations["length"], 1557)
            self.assertEqual(alignment.query.annotations["start"], 192)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 0)
            self.assertEqual(alignment.target.annotations["end"], 156)
            self.assertEqual(
                alignment.target.seq,
                "MACATKNAKVVAISLGSLQRLIALKAVPQSDVPLIIKTMSDSMSQGVDIQLK",
            )
            self.assertEqual(
                alignment.query.seq,
                "LACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.50)
            self.assertAlmostEqual(alignment.annotations["bit score"], 38.6)
            self.assertAlmostEqual(alignment.score, 78)
            self.assertEqual(alignment.shape, (2, 52))
            self.assertAlmostEqual(alignment.annotations["% identity"], 28.85)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 37)
            self.assertEqual(alignment.annotations["positives"], 32)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 61.54)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "554373")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Moniliophthora perniciosa FA553 hypothetical protein (MPER_09344) mRNA, partial cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Moniliophthora perniciosa FA553 hypothetical protein (MPER_09344) mRNA, partial cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 45)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 45)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|82734234|ref|NM_020336.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|82734234|ref|NM_020336.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "82734234")
            self.assertEqual(alignment.target.annotations["gis"], "82734234")
            self.assertEqual(alignment.target.annotations["acc."], "NM_020336")
            self.assertEqual(alignment.target.annotations["accs."], "NM_020336")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_020336.2")
            self.assertEqual(alignment.target.annotations["length"], 8636)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6901)
            self.assertEqual(alignment.target.annotations["end"], 6780)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEEVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.50)
            self.assertAlmostEqual(alignment.annotations["bit score"], 38.6)
            self.assertAlmostEqual(alignment.score, 78)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9606")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Homo sapiens Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Homo sapiens Ral GTPase activating protein, beta subunit (non-catalytic) (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|391342729|ref|XM_003745620.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|391342729|ref|XM_003745620.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "391342729")
            self.assertEqual(alignment.target.annotations["gis"], "391342729")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003745620")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003745620")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003745620.1")
            self.assertEqual(alignment.target.annotations["length"], 4662)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 210)
            self.assertEqual(alignment.target.annotations["end"], 291)
            self.assertEqual(alignment.target.seq, "FMAPFELACQSKSPRLTVIALDCVQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.69)
            self.assertAlmostEqual(alignment.annotations["bit score"], 38.2)
            self.assertAlmostEqual(alignment.score, 77)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "34638")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Metaseiulus occidentalis brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100907146), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Metaseiulus occidentalis brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100907146), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|291235727|ref|XM_002737750.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|291235727|ref|XM_002737750.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "291235727")
            self.assertEqual(alignment.target.annotations["gis"], "291235727")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002737750")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002737750")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002737750.1")
            self.assertEqual(alignment.target.annotations["length"], 4743)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 198)
            self.assertEqual(alignment.target.annotations["end"], 279)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSARIVNTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.69)
            self.assertAlmostEqual(alignment.annotations["bit score"], 38.2)
            self.assertAlmostEqual(alignment.score, 77)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 51.85)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "10224")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Saccoglossus kowalevskii ADP-ribosylation factor guanine nucleotide-exchange factor 1(brefeldin A-inhibited)-like (LOC100366823), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Saccoglossus kowalevskii ADP-ribosylation factor guanine nucleotide-exchange factor 1(brefeldin A-inhibited)-like (LOC100366823), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  32],
                                 [243, 275]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|330938727|ref|XM_003305716.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|330938727|ref|XM_003305716.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "330938727")
            self.assertEqual(alignment.target.annotations["gis"], "330938727")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003305716")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003305716")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003305716.1")
            self.assertEqual(alignment.target.annotations["length"], 459)
            self.assertEqual(alignment.query.annotations["start"], 243)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 163)
            self.assertEqual(alignment.target.annotations["end"], 69)
            self.assertEqual(alignment.target.seq, "ISAMSPVPVLARVRLSDVDDAYFRISHVVSDL")
            self.assertEqual(alignment.query.seq, "LQGLSTVPSIPRSRLSEILDAFIEATHLAMEI")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.77)
            self.assertAlmostEqual(alignment.annotations["bit score"], 29.9)
            self.assertAlmostEqual(alignment.score, 59)
            self.assertEqual(alignment.shape, (2, 32))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.25)
            self.assertEqual(alignment.annotations["identical"], 10)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.50)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "861557")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pyrenophora teres f. teres 0-1 hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pyrenophora teres f. teres 0-1 hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 42)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 27)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  17],
                                 [117, 134]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|330938727|ref|XM_003305716.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|330938727|ref|XM_003305716.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "330938727")
            self.assertEqual(alignment.target.annotations["gis"], "330938727")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003305716")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003305716")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003305716.1")
            self.assertEqual(alignment.target.annotations["length"], 459)
            self.assertEqual(alignment.query.annotations["start"], 117)
            self.assertEqual(alignment.query.annotations["end"], 168)
            self.assertEqual(alignment.target.annotations["start"], 446)
            self.assertEqual(alignment.target.annotations["end"], 397)
            self.assertEqual(alignment.target.seq, "SLPVIIRTHSLPQLERH")
            self.assertEqual(alignment.query.seq, "SIEILKRVHSFEELERH")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.77)
            self.assertAlmostEqual(alignment.annotations["bit score"], 24.4)
            self.assertAlmostEqual(alignment.score, 47)
            self.assertEqual(alignment.shape, (2, 17))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.06)
            self.assertEqual(alignment.annotations["identical"], 8)
            self.assertEqual(alignment.annotations["mismatches"], 9)
            self.assertEqual(alignment.annotations["positives"], 12)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.59)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "861557")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pyrenophora teres f. teres 0-1 hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pyrenophora teres f. teres 0-1 hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 42)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 15)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|397511126|ref|XM_003825883.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|397511126|ref|XM_003825883.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "397511126")
            self.assertEqual(alignment.target.annotations["gis"], "397511126")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003825883")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003825883")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003825883.1")
            self.assertEqual(alignment.target.annotations["length"], 8056)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6170)
            self.assertEqual(alignment.target.annotations["end"], 6049)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9597")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan paniscus Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan paniscus Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|397511124|ref|XM_003825882.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|397511124|ref|XM_003825882.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "397511124")
            self.assertEqual(alignment.target.annotations["gis"], "397511124")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003825882")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003825882")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003825882.1")
            self.assertEqual(alignment.target.annotations["length"], 8831)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6945)
            self.assertEqual(alignment.target.annotations["end"], 6824)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9597")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan paniscus Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan paniscus Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  25],
                                 [180, 205]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|390362724|ref|XR_025702.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|390362724|ref|XR_025702.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "390362724")
            self.assertEqual(alignment.target.annotations["gis"], "390362724")
            self.assertEqual(alignment.target.annotations["acc."], "XR_025702")
            self.assertEqual(alignment.target.annotations["accs."], "XR_025702")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XR_025702.2")
            self.assertEqual(alignment.target.annotations["length"], 5049)
            self.assertEqual(alignment.query.annotations["start"], 180)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 318)
            self.assertEqual(alignment.target.seq, "LPFELACQSKSARIVNTALDCLQKL")
            self.assertEqual(alignment.query.seq, "LPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 25))
            self.assertAlmostEqual(alignment.annotations["% identity"], 56.00)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 11)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 76.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7668")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Strongylocentrotus purpuratus brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC754128), misc_RNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Strongylocentrotus purpuratus brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC754128), misc_RNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 21)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 21)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  25],
                                 [180, 205]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|390341406|ref|XR_143615.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|390341406|ref|XR_143615.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "390341406")
            self.assertEqual(alignment.target.annotations["gis"], "390341406")
            self.assertEqual(alignment.target.annotations["acc."], "XR_143615")
            self.assertEqual(alignment.target.annotations["accs."], "XR_143615")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XR_143615.1")
            self.assertEqual(alignment.target.annotations["length"], 4439)
            self.assertEqual(alignment.query.annotations["start"], 180)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 791)
            self.assertEqual(alignment.target.annotations["end"], 866)
            self.assertEqual(alignment.target.seq, "LPFELACQSKSARIVNTALDCLQKL")
            self.assertEqual(alignment.query.seq, "LPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 25))
            self.assertAlmostEqual(alignment.annotations["% identity"], 56.00)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 11)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 76.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "7668")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Strongylocentrotus purpuratus brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC586243), misc_RNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Strongylocentrotus purpuratus brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC586243), misc_RNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 21)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 21)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332858441|ref|XM_003316935.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332858441|ref|XM_003316935.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332858441")
            self.assertEqual(alignment.target.annotations["gis"], "332858441")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003316935")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003316935")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003316935.1")
            self.assertEqual(alignment.target.annotations["length"], 8054)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6170)
            self.assertEqual(alignment.target.annotations["end"], 6049)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332858439|ref|XM_003316934.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332858439|ref|XM_003316934.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332858439")
            self.assertEqual(alignment.target.annotations["gis"], "332858439")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003316934")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003316934")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003316934.1")
            self.assertEqual(alignment.target.annotations["length"], 8593)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6709)
            self.assertEqual(alignment.target.annotations["end"], 6588)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332858437|ref|XM_514640.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332858437|ref|XM_514640.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332858437")
            self.assertEqual(alignment.target.annotations["gis"], "332858437")
            self.assertEqual(alignment.target.annotations["acc."], "XM_514640")
            self.assertEqual(alignment.target.annotations["accs."], "XM_514640")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_514640.3")
            self.assertEqual(alignment.target.annotations["length"], 8829)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6945)
            self.assertEqual(alignment.target.annotations["end"], 6824)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNTLELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 0.95)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.7)
            self.assertAlmostEqual(alignment.score, 76)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 3 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 3 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470302053|ref|XM_004347467.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470302053|ref|XM_004347467.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470302053")
            self.assertEqual(alignment.target.annotations["gis"], "470302053")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004347467")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004347467")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004347467.1")
            self.assertEqual(alignment.target.annotations["length"], 6093)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 231)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(alignment.target.seq, "YFLPFQLACETQNVKITVTTLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.3)
            self.assertAlmostEqual(alignment.annotations["bit score"], 37.3)
            self.assertAlmostEqual(alignment.score, 75)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "595528")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Capsaspora owczarzaki ATCC 30864 guanine nucleotide-exchange protein (CAOG_04766) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Capsaspora owczarzaki ATCC 30864 guanine nucleotide-exchange protein (CAOG_04766) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  68],
                                 [ 96, 164]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|449435759|ref|XM_004135614.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|449435759|ref|XM_004135614.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "449435759")
            self.assertEqual(alignment.target.annotations["gis"], "449435759")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004135614")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004135614")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004135614.1")
            self.assertEqual(alignment.target.annotations["length"], 4903)
            self.assertEqual(alignment.query.annotations["start"], 96)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 72)
            self.assertEqual(alignment.target.annotations["end"], 276)
            self.assertEqual(
                alignment.target.seq,
                "VKDGAEHAILKLRTMSCPSDIAENEDILRIFLLACEAKTIKLSVIGLSSLQKLISHDAVTPSALKEIL",
            )
            self.assertEqual(
                alignment.query.seq,
                "IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 68))
            self.assertAlmostEqual(alignment.annotations["% identity"], 23.53)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 52)
            self.assertEqual(alignment.annotations["positives"], 37)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 54.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "3659")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cucumis sativus protein MON2 homolog (LOC101218514), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cucumis sativus protein MON2 homolog (LOC101218514), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 58)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 58)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|426391663|ref|XM_004062140.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|426391663|ref|XM_004062140.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "426391663")
            self.assertEqual(alignment.target.annotations["gis"], "426391663")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004062140")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004062140")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004062140.1")
            self.assertEqual(alignment.target.annotations["length"], 8057)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6171)
            self.assertEqual(alignment.target.annotations["end"], 6050)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNILELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9595")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Gorilla gorilla gorilla Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Gorilla gorilla gorilla Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 2 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  41],
                                 [225, 266]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|426391661|ref|XM_004062139.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|426391661|ref|XM_004062139.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "426391661")
            self.assertEqual(alignment.target.annotations["gis"], "426391661")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004062139")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004062139")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004062139.1")
            self.assertEqual(alignment.target.annotations["length"], 8832)
            self.assertEqual(alignment.query.annotations["start"], 225)
            self.assertEqual(alignment.query.annotations["end"], 348)
            self.assertEqual(alignment.target.annotations["start"], 6946)
            self.assertEqual(alignment.target.annotations["end"], 6825)
            self.assertEqual(
                alignment.target.seq, "TLGVSCLQGLHILPSLEDEGVSQITNAFNMIVHVSNILELQ"
            )
            self.assertEqual(
                alignment.query.seq, "TLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 41))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.59)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 26)
            self.assertEqual(alignment.annotations["positives"], 26)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.41)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9595")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Gorilla gorilla gorilla Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Gorilla gorilla gorilla Ral GTPase activating protein, beta subunit (non-catalytic), transcript variant 1 (RALGAPB), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 35)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 35)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|347973012|ref|XM_319652.4|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|347973012|ref|XM_319652.4|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "347973012")
            self.assertEqual(alignment.target.annotations["gis"], "347973012")
            self.assertEqual(alignment.target.annotations["acc."], "XM_319652")
            self.assertEqual(alignment.target.annotations["accs."], "XM_319652")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_319652.4")
            self.assertEqual(alignment.target.annotations["length"], 5006)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 246)
            self.assertEqual(alignment.target.annotations["end"], 327)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRTPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 51.85)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "180454")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Anopheles gambiae str. PEST AGAP008906-PA (AgaP_AGAP008906) mRNA, partial cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Anopheles gambiae str. PEST AGAP008906-PA (AgaP_AGAP008906) mRNA, partial cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|339252087|ref|XM_003371219.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|339252087|ref|XM_003371219.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "339252087")
            self.assertEqual(alignment.target.annotations["gis"], "339252087")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003371219")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003371219")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003371219.1")
            self.assertEqual(alignment.target.annotations["length"], 3699)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 222)
            self.assertEqual(alignment.target.annotations["end"], 303)
            self.assertEqual(alignment.target.seq, "YFLPFELACSSKSTKIVVIALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.8)
            self.assertAlmostEqual(alignment.score, 74)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "6334")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Trichinella spiralis putative Sec7 domain protein (Tsp_09497) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Trichinella spiralis putative Sec7 domain protein (Tsp_09497) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  32],
                                 [243, 275]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|189192213|ref|XM_001932411.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|189192213|ref|XM_001932411.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "189192213")
            self.assertEqual(alignment.target.annotations["gis"], "189192213")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001932411")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001932411")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001932411.1")
            self.assertEqual(alignment.target.annotations["length"], 769)
            self.assertEqual(alignment.query.annotations["start"], 243)
            self.assertEqual(alignment.query.annotations["end"], 339)
            self.assertEqual(alignment.target.annotations["start"], 334)
            self.assertEqual(alignment.target.annotations["end"], 240)
            self.assertEqual(alignment.target.seq, "ISAMSPVPVLARVRLSDVADAYFRINHVVSDL")
            self.assertEqual(alignment.query.seq, "LQGLSTVPSIPRSRLSEILDAFIEATHLAMEI")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.9)
            self.assertAlmostEqual(alignment.annotations["bit score"], 30.9)
            self.assertAlmostEqual(alignment.score, 61)
            self.assertEqual(alignment.shape, (2, 32))
            self.assertAlmostEqual(alignment.annotations["% identity"], 31.25)
            self.assertEqual(alignment.annotations["identical"], 10)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 59.38)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "426418")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pyrenophora tritici-repentis Pt-1C-BFP conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pyrenophora tritici-repentis Pt-1C-BFP conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 43)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 27)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  18],
                                 [114, 132]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|189192213|ref|XM_001932411.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|189192213|ref|XM_001932411.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "189192213")
            self.assertEqual(alignment.target.annotations["gis"], "189192213")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001932411")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001932411")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001932411.1")
            self.assertEqual(alignment.target.annotations["length"], 769)
            self.assertEqual(alignment.query.annotations["start"], 114)
            self.assertEqual(alignment.query.annotations["end"], 168)
            self.assertEqual(alignment.target.annotations["start"], 620)
            self.assertEqual(alignment.target.annotations["end"], 568)
            self.assertEqual(alignment.target.seq, "RSLPIIIRAHGLPQLERH")
            self.assertEqual(alignment.query.seq, "KSIEILKRVHSFEELERH")
            self.assertAlmostEqual(alignment.annotations["evalue"], 1.9)
            self.assertAlmostEqual(alignment.annotations["bit score"], 24.0)
            self.assertAlmostEqual(alignment.score, 46)
            self.assertEqual(alignment.shape, (2, 18))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 8)
            self.assertEqual(alignment.annotations["mismatches"], 10)
            self.assertEqual(alignment.annotations["positives"], 12)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/-2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "426418")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pyrenophora tritici-repentis Pt-1C-BFP conserved hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pyrenophora tritici-repentis Pt-1C-BFP conserved hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 43)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 15)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|426242124|ref|XM_004014876.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|426242124|ref|XM_004014876.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "426242124")
            self.assertEqual(alignment.target.annotations["gis"], "426242124")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004014876")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004014876")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004014876.1")
            self.assertEqual(alignment.target.annotations["length"], 5780)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 240)
            self.assertEqual(alignment.target.annotations["end"], 321)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2.5)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9940")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Ovis aries ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Ovis aries ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|329663901|ref|NM_001205652.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|329663901|ref|NM_001205652.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "329663901")
            self.assertEqual(alignment.target.annotations["gis"], "329663901")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001205652")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001205652")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001205652.1")
            self.assertEqual(alignment.target.annotations["length"], 8869)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 2.5)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9913")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Bos taurus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Bos taurus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  38],
                                 [183, 221]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|167533856|ref|XM_001748555.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|167533856|ref|XM_001748555.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "167533856")
            self.assertEqual(alignment.target.annotations["gis"], "167533856")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001748555")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001748555")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001748555.1")
            self.assertEqual(alignment.target.annotations["length"], 5818)
            self.assertEqual(alignment.query.annotations["start"], 183)
            self.assertEqual(alignment.query.annotations["end"], 297)
            self.assertEqual(alignment.target.annotations["start"], 619)
            self.assertEqual(alignment.target.annotations["end"], 733)
            self.assertEqual(
                alignment.target.seq, "PFRLACECKSAKVTRTALDCLQKMMAYGHINSHMMAEV"
            )
            self.assertEqual(
                alignment.query.seq, "PFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEI"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 2.5)
            self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
            self.assertAlmostEqual(alignment.score, 73)
            self.assertEqual(alignment.shape, (2, 38))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.84)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.53)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "431895")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Monosiga brevicollis MX1 predicted protein MONBRDRAFT_33770 mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Monosiga brevicollis MX1 predicted protein MONBRDRAFT_33770 mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 33)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410970929|ref|XM_003991879.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410970929|ref|XM_003991879.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410970929")
            self.assertEqual(alignment.target.annotations["gis"], "410970929")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003991879")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003991879")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003991879.1")
            self.assertEqual(alignment.target.annotations["length"], 3983)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 3234)
            self.assertEqual(alignment.target.annotations["end"], 3294)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/1")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9685")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Felis catus EPH receptor B3 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Felis catus EPH receptor B3 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410929672|ref|XM_003978175.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410929672|ref|XM_003978175.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410929672")
            self.assertEqual(alignment.target.annotations["gis"], "410929672")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003978175")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003978175")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003978175.1")
            self.assertEqual(alignment.target.annotations["length"], 4929)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 231)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(alignment.target.seq, "YVLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "31033")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Takifugu rubripes brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC101076459), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Takifugu rubripes brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC101076459), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  38],
                                 [309, 271]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|402903089|ref|XM_003914364.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|402903089|ref|XM_003914364.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "402903089")
            self.assertEqual(alignment.target.annotations["gis"], "402903089")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003914364")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003914364")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003914364.1")
            self.assertEqual(alignment.target.annotations["length"], 3776)
            self.assertEqual(alignment.query.annotations["start"], 308)
            self.assertEqual(alignment.query.annotations["end"], 196)
            self.assertEqual(alignment.target.annotations["start"], 2580)
            self.assertEqual(alignment.target.annotations["end"], 2468)
            self.assertEqual(
                alignment.target.seq, "DSISSFEKTGARSQWRGTQDSSGDPCRGRSFQLP*LAT"
            )
            self.assertEqual(
                alignment.query.seq, "EGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LAS"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 38))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.84)
            self.assertEqual(alignment.annotations["identical"], 14)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 60.53)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-3/-2")
            self.assertEqual(alignment.query.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9555")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Papio anubis CBP80/20-dependent translation initiation factor-like (LOC101009629), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Papio anubis CBP80/20-dependent translation initiation factor-like (LOC101009629), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 33)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|383853967|ref|XM_003702446.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|383853967|ref|XM_003702446.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "383853967")
            self.assertEqual(alignment.target.annotations["gis"], "383853967")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003702446")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003702446")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003702446.1")
            self.assertEqual(alignment.target.annotations["length"], 5094)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 216)
            self.assertEqual(alignment.target.annotations["end"], 297)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "143995")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Megachile rotundata ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Megachile rotundata ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|380017270|ref|XM_003692535.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|380017270|ref|XM_003692535.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "380017270")
            self.assertEqual(alignment.target.annotations["gis"], "380017270")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003692535")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003692535")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003692535.1")
            self.assertEqual(alignment.target.annotations["length"], 5723)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 521)
            self.assertEqual(alignment.target.annotations["end"], 602)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "7463")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Apis florea ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Apis florea ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|350411438|ref|XM_003489304.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350411438|ref|XM_003489304.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "350411438")
            self.assertEqual(alignment.target.annotations["gis"], "350411438")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003489304")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003489304")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003489304.1")
            self.assertEqual(alignment.target.annotations["length"], 5094)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 216)
            self.assertEqual(alignment.target.annotations["end"], 297)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "132113")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Bombus impatiens brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100743555), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Bombus impatiens brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100743555), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|348539090|ref|XM_003456975.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|348539090|ref|XM_003456975.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "348539090")
            self.assertEqual(alignment.target.annotations["gis"], "348539090")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003456975")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003456975")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003456975.1")
            self.assertEqual(alignment.target.annotations["length"], 5589)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 306)
            self.assertEqual(alignment.target.annotations["end"], 387)
            self.assertEqual(alignment.target.seq, "YVLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "8128")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Oreochromis niloticus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Oreochromis niloticus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|345796385|ref|XM_003434116.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|345796385|ref|XM_003434116.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "345796385")
            self.assertEqual(alignment.target.annotations["gis"], "345796385")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003434116")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003434116")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003434116.1")
            self.assertEqual(alignment.target.annotations["length"], 3664)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2945)
            self.assertEqual(alignment.target.annotations["end"], 3005)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9615")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Canis lupus familiaris EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Canis lupus familiaris EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|345796383|ref|XM_545232.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|345796383|ref|XM_545232.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "345796383")
            self.assertEqual(alignment.target.annotations["gis"], "345796383")
            self.assertEqual(alignment.target.annotations["acc."], "XM_545232")
            self.assertEqual(alignment.target.annotations["accs."], "XM_545232")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_545232.3")
            self.assertEqual(alignment.target.annotations["length"], 3660)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2941)
            self.assertEqual(alignment.target.annotations["end"], 3001)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9615")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Canis lupus familiaris EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Canis lupus familiaris EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|340729748|ref|XM_003403110.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|340729748|ref|XM_003403110.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "340729748")
            self.assertEqual(alignment.target.annotations["gis"], "340729748")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003403110")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003403110")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003403110.1")
            self.assertEqual(alignment.target.annotations["length"], 7331)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 621)
            self.assertEqual(alignment.target.annotations["end"], 702)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "30195")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Bombus terrestris brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100648040), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Bombus terrestris brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100648040), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|338716130|ref|XM_001497451.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|338716130|ref|XM_001497451.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "338716130")
            self.assertEqual(alignment.target.annotations["gis"], "338716130")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001497451")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001497451")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001497451.3")
            self.assertEqual(alignment.target.annotations["length"], 3659)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2940)
            self.assertEqual(alignment.target.annotations["end"], 3000)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/1")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9796")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Equus caballus EPH receptor B3 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Equus caballus EPH receptor B3 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|328778548|ref|XM_003249467.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|328778548|ref|XM_003249467.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "328778548")
            self.assertEqual(alignment.target.annotations["gis"], "328778548")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003249467")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003249467")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003249467.1")
            self.assertEqual(alignment.target.annotations["length"], 5773)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 519)
            self.assertEqual(alignment.target.annotations["end"], 600)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7460")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Apis mellifera sec71 protein (sec71), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Apis mellifera sec71 protein (sec71), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|301759744|ref|XM_002915676.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|301759744|ref|XM_002915676.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "301759744")
            self.assertEqual(alignment.target.annotations["gis"], "301759744")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002915676")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002915676")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002915676.1")
            self.assertEqual(alignment.target.annotations["length"], 3673)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2954)
            self.assertEqual(alignment.target.annotations["end"], 3014)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9646")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Ailuropoda melanoleuca EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Ailuropoda melanoleuca EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|301759742|ref|XM_002915675.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|301759742|ref|XM_002915675.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "301759742")
            self.assertEqual(alignment.target.annotations["gis"], "301759742")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002915675")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002915675")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002915675.1")
            self.assertEqual(alignment.target.annotations["length"], 3658)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2939)
            self.assertEqual(alignment.target.annotations["end"], 2999)
            self.assertEqual(alignment.target.seq, "AGLLDFWMPGLRLWPRRWKF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9646")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Ailuropoda melanoleuca EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Ailuropoda melanoleuca EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|292626951|ref|XM_002666467.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|292626951|ref|XM_002666467.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "292626951")
            self.assertEqual(alignment.target.annotations["gis"], "292626951")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002666467")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002666467")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002666467.1")
            self.assertEqual(alignment.target.annotations["length"], 5942)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 405)
            self.assertEqual(alignment.target.annotations["end"], 486)
            self.assertEqual(alignment.target.seq, "YVLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7955")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Danio rerio ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Danio rerio ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (arfgef2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  29],
                                 [226, 255]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|237836078|ref|XM_002367296.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|237836078|ref|XM_002367296.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "237836078")
            self.assertEqual(alignment.target.annotations["gis"], "237836078")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002367296")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002367296")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002367296.1")
            self.assertEqual(alignment.target.annotations["length"], 6159)
            self.assertEqual(alignment.query.annotations["start"], 226)
            self.assertEqual(alignment.query.annotations["end"], 313)
            self.assertEqual(alignment.target.annotations["start"], 1016)
            self.assertEqual(alignment.target.annotations["end"], 1103)
            self.assertEqual(alignment.target.seq, "PWCRDAQRECRPFSFFVR*RCKRFFSPGL")
            self.assertEqual(alignment.query.seq, "PWQCNAYRDCQPFHLFLEAGCLKFWMPSL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 3.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.9)
            self.assertAlmostEqual(alignment.score, 72)
            self.assertEqual(alignment.shape, (2, 29))
            self.assertAlmostEqual(alignment.annotations["% identity"], 41.38)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 17)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "508771")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Toxoplasma gondii ME49 hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Toxoplasma gondii ME49 hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 25)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 25)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  26],
                                 [144, 170]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|396462349|ref|XM_003835738.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|396462349|ref|XM_003835738.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "396462349")
            self.assertEqual(alignment.target.annotations["gis"], "396462349")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003835738")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003835738")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003835738.1")
            self.assertEqual(alignment.target.annotations["length"], 6858)
            self.assertEqual(alignment.query.annotations["start"], 144)
            self.assertEqual(alignment.query.annotations["end"], 222)
            self.assertEqual(alignment.target.annotations["start"], 402)
            self.assertEqual(alignment.target.annotations["end"], 480)
            self.assertEqual(alignment.target.seq, "SRKDLSRRPHFISPFLIACGTRNAKV")
            self.assertEqual(alignment.query.seq, "SFEELERHPDFALPFVLACQSRNAKM")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 26))
            self.assertAlmostEqual(alignment.annotations["% identity"], 50.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 73.08)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "985895")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Leptosphaeria maculans JN3 hypothetical protein (LEMA_P051270.1) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Leptosphaeria maculans JN3 hypothetical protein (LEMA_P051270.1) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 22)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 22)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|268570183|ref|XM_002640666.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|268570183|ref|XM_002640666.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "268570183")
            self.assertEqual(alignment.target.annotations["gis"], "268570183")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002640666")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002640666")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002640666.1")
            self.assertEqual(alignment.target.annotations["length"], 4782)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 249)
            self.assertEqual(alignment.target.annotations["end"], 330)
            self.assertEqual(alignment.target.seq, "YFLPFELACNSKNPRVVITALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "6238")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Caenorhabditis briggsae C. briggsae CBR-AGEF-1 protein (Cbr-agef-1) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Caenorhabditis briggsae C. briggsae CBR-AGEF-1 protein (Cbr-agef-1) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|198473316|ref|XM_001356210.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|198473316|ref|XM_001356210.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "198473316")
            self.assertEqual(alignment.target.annotations["gis"], "198473316")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001356210")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001356210")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001356210.2")
            self.assertEqual(alignment.target.annotations["length"], 4935)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "46245")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila pseudoobscura pseudoobscura GA20452 (Dpse\GA20452), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila pseudoobscura pseudoobscura GA20452 (Dpse\GA20452), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  28],
                                 [171, 199]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|196008366|ref|XM_002114013.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|196008366|ref|XM_002114013.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "196008366")
            self.assertEqual(alignment.target.annotations["gis"], "196008366")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002114013")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002114013")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002114013.1")
            self.assertEqual(alignment.target.annotations["length"], 5498)
            self.assertEqual(alignment.query.annotations["start"], 171)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 225)
            self.assertEqual(alignment.target.annotations["end"], 309)
            self.assertEqual(alignment.target.seq, "DYFLPFELACKSRCSRIVIASLDCLQKL")
            self.assertEqual(alignment.query.seq, "DFALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 28))
            self.assertAlmostEqual(alignment.annotations["% identity"], 46.43)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 71.43)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "10228")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Trichoplax adhaerens hypothetical protein, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Trichoplax adhaerens hypothetical protein, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 24)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 24)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195579057|ref|XM_002079343.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195579057|ref|XM_002079343.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195579057")
            self.assertEqual(alignment.target.annotations["gis"], "195579057")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002079343")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002079343")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002079343.1")
            self.assertEqual(alignment.target.annotations["length"], 4869)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 219)
            self.assertEqual(alignment.target.annotations["end"], 300)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7240")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila simulans GD23923 (Dsim\GD23923), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila simulans GD23923 (Dsim\GD23923), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195472698|ref|XM_002088601.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195472698|ref|XM_002088601.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195472698")
            self.assertEqual(alignment.target.annotations["gis"], "195472698")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002088601")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002088601")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002088601.1")
            self.assertEqual(alignment.target.annotations["length"], 4962)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7245")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila yakuba GE18681 (Dyak\GE18681), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila yakuba GE18681 (Dyak\GE18681), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195438259|ref|XM_002067019.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195438259|ref|XM_002067019.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195438259")
            self.assertEqual(alignment.target.annotations["gis"], "195438259")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002067019")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002067019")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002067019.1")
            self.assertEqual(alignment.target.annotations["length"], 5019)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7260")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila willistoni GK24228 (Dwil\GK24228), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila willistoni GK24228 (Dwil\GK24228), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195397689|ref|XM_002057425.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195397689|ref|XM_002057425.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195397689")
            self.assertEqual(alignment.target.annotations["gis"], "195397689")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002057425")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002057425")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002057425.1")
            self.assertEqual(alignment.target.annotations["length"], 5145)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7244")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila virilis GJ18143 (Dvir\GJ18143), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila virilis GJ18143 (Dvir\GJ18143), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195338276|ref|XM_002035715.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195338276|ref|XM_002035715.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195338276")
            self.assertEqual(alignment.target.annotations["gis"], "195338276")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002035715")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002035715")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002035715.1")
            self.assertEqual(alignment.target.annotations["length"], 4962)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7238")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila sechellia GM15214 (Dsec\GM15214), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila sechellia GM15214 (Dsec\GM15214), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195164721|ref|XM_002023159.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195164721|ref|XM_002023159.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195164721")
            self.assertEqual(alignment.target.annotations["gis"], "195164721")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002023159")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002023159")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002023159.1")
            self.assertEqual(alignment.target.annotations["length"], 4935)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7234")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila persimilis GL21229 (Dper\GL21229), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila persimilis GL21229 (Dper\GL21229), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195119048|ref|XM_002004008.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195119048|ref|XM_002004008.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195119048")
            self.assertEqual(alignment.target.annotations["gis"], "195119048")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002004008")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002004008")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002004008.1")
            self.assertEqual(alignment.target.annotations["length"], 5133)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7230")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila mojavensis GI18236 (Dmoj\GI18236), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila mojavensis GI18236 (Dmoj\GI18236), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|195031427|ref|XM_001988304.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|195031427|ref|XM_001988304.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "195031427")
            self.assertEqual(alignment.target.annotations["gis"], "195031427")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001988304")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001988304")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001988304.1")
            self.assertEqual(alignment.target.annotations["length"], 5130)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7222")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila grimshawi GH11113 (Dgri\GH11113), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila grimshawi GH11113 (Dgri\GH11113), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|194860432|ref|XM_001969546.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|194860432|ref|XM_001969546.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "194860432")
            self.assertEqual(alignment.target.annotations["gis"], "194860432")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001969546")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001969546")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001969546.1")
            self.assertEqual(alignment.target.annotations["length"], 4962)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 243)
            self.assertEqual(alignment.target.annotations["end"], 324)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7220")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila erecta GG23880 (Dere\GG23880), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila erecta GG23880 (Dere\GG23880), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|194761139|ref|XM_001962754.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|194761139|ref|XM_001962754.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "194761139")
            self.assertEqual(alignment.target.annotations["gis"], "194761139")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001962754")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001962754")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001962754.1")
            self.assertEqual(alignment.target.annotations["length"], 4971)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 246)
            self.assertEqual(alignment.target.annotations["end"], 327)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7217")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                r"Drosophila ananassae GF14256 (Dana\GF14256), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                r"Drosophila ananassae GF14256 (Dana\GF14256), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|170037186|ref|XM_001846389.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|170037186|ref|XM_001846389.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "170037186")
            self.assertEqual(alignment.target.annotations["gis"], "170037186")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001846389")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001846389")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001846389.1")
            self.assertEqual(alignment.target.annotations["length"], 6192)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 1356)
            self.assertEqual(alignment.target.annotations["end"], 1437)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKTPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7176")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Culex quinquefasciatus brefeldin A-inhibited guanine nucleotide-exchange protein 1, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Culex quinquefasciatus brefeldin A-inhibited guanine nucleotide-exchange protein 1, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|157134230|ref|XM_001663149.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|157134230|ref|XM_001663149.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "157134230")
            self.assertEqual(alignment.target.annotations["gis"], "157134230")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001663149")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001663149")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001663149.1")
            self.assertEqual(alignment.target.annotations["length"], 5320)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 132)
            self.assertEqual(alignment.target.annotations["end"], 213)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKTPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7159")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aedes aegypti brefeldin a-inhibited guanine nucleotide-exchange protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aedes aegypti brefeldin a-inhibited guanine nucleotide-exchange protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156386529|ref|XM_001633915.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156386529|ref|XM_001633915.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156386529")
            self.assertEqual(alignment.target.annotations["gis"], "156386529")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001633915")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001633915")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001633915.1")
            self.assertEqual(alignment.target.annotations["length"], 5502)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 213)
            self.assertEqual(alignment.target.annotations["end"], 294)
            self.assertEqual(alignment.target.seq, "YLLPFELACQSKCPRIVTTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "45351")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g102625) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g102625) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|24584188|ref|NM_165059.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|24584188|ref|NM_165059.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "24584188")
            self.assertEqual(alignment.target.annotations["gis"], "24584188")
            self.assertEqual(alignment.target.annotations["acc."], "NM_165059")
            self.assertEqual(alignment.target.annotations["accs."], "NM_165059")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_165059.1")
            self.assertEqual(alignment.target.annotations["length"], 5672)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 541)
            self.assertEqual(alignment.target.annotations["end"], 622)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "7227")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Drosophila melanogaster sec71 (sec71), transcript variant B, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Drosophila melanogaster sec71 (sec71), transcript variant B, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|24584186|ref|NM_135831.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|24584186|ref|NM_135831.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "24584186")
            self.assertEqual(alignment.target.annotations["gis"], "24584186")
            self.assertEqual(alignment.target.annotations["acc."], "NM_135831")
            self.assertEqual(alignment.target.annotations["accs."], "NM_135831")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_135831.2")
            self.assertEqual(alignment.target.annotations["length"], 5799)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 544)
            self.assertEqual(alignment.target.annotations["end"], 625)
            self.assertEqual(alignment.target.seq, "YFLPFELACKSRSPRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 4.6)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.4)
            self.assertAlmostEqual(alignment.score, 71)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "7227")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Drosophila melanogaster sec71 (sec71), transcript variant A, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Drosophila melanogaster sec71 (sec71), transcript variant A, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  23],
                                 [145, 122]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|157110325|ref|XM_001651005.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|157110325|ref|XM_001651005.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "157110325")
            self.assertEqual(alignment.target.annotations["gis"], "157110325")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001651005")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001651005")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001651005.1")
            self.assertEqual(alignment.target.annotations["length"], 9654)
            self.assertEqual(alignment.query.annotations["start"], 144)
            self.assertEqual(alignment.query.annotations["end"], 77)
            self.assertEqual(alignment.target.annotations["start"], 5690)
            self.assertEqual(alignment.target.annotations["end"], 5623)
            self.assertEqual(alignment.target.seq, "FLIVGSNCWLFIVSSDWLNFFFS")
            self.assertEqual(alignment.query.seq, "YVLFSISQWIYH*HGEWLNFFFS")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.2)
            self.assertAlmostEqual(alignment.annotations["bit score"], 27.6)
            self.assertAlmostEqual(alignment.score, 54)
            self.assertEqual(alignment.shape, (2, 23))
            self.assertAlmostEqual(alignment.annotations["% identity"], 34.78)
            self.assertEqual(alignment.annotations["identical"], 8)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 15)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.22)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7159")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aedes aegypti hypothetical protein AaeL_AAEL005529 partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aedes aegypti hypothetical protein AaeL_AAEL005529 partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 40)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 20)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  33],
                                 [103,  70]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|157110325|ref|XM_001651005.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|157110325|ref|XM_001651005.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "157110325")
            self.assertEqual(alignment.target.annotations["gis"], "157110325")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001651005")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001651005")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001651005.1")
            self.assertEqual(alignment.target.annotations["length"], 9654)
            self.assertEqual(alignment.query.annotations["start"], 102)
            self.assertEqual(alignment.query.annotations["end"], 5)
            self.assertEqual(alignment.target.annotations["start"], 5516)
            self.assertEqual(alignment.target.annotations["end"], 5419)
            self.assertEqual(alignment.target.seq, "GNWFHFFFSWFLIVGSNWLNFFLSWFFIISRNW")
            self.assertEqual(alignment.query.seq, "GEWLNFFFSIRKIKNAILLQVAFAWSQTLQCSW")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.2)
            self.assertAlmostEqual(alignment.annotations["bit score"], 24.9)
            self.assertAlmostEqual(alignment.score, 48)
            self.assertEqual(alignment.shape, (2, 33))
            self.assertAlmostEqual(alignment.annotations["% identity"], 30.30)
            self.assertEqual(alignment.annotations["identical"], 10)
            self.assertEqual(alignment.annotations["mismatches"], 23)
            self.assertEqual(alignment.annotations["positives"], 15)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 45.45)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/-1")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7159")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aedes aegypti hypothetical protein AaeL_AAEL005529 partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aedes aegypti hypothetical protein AaeL_AAEL005529 partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 40)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 28)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  23],
                                 [253, 276]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156388828|ref|XM_001634645.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156388828|ref|XM_001634645.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156388828")
            self.assertEqual(alignment.target.annotations["gis"], "156388828")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001634645")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001634645")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001634645.1")
            self.assertEqual(alignment.target.annotations["length"], 528)
            self.assertEqual(alignment.query.annotations["start"], 253)
            self.assertEqual(alignment.query.annotations["end"], 322)
            self.assertEqual(alignment.target.annotations["start"], 352)
            self.assertEqual(alignment.target.annotations["end"], 421)
            self.assertEqual(alignment.target.seq, "CQPFLRFLEWGNMDL*LPALLVL")
            self.assertEqual(alignment.query.seq, "CQPFHLFLEAGCLKFWMPSLRLL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 26.3)
            self.assertAlmostEqual(alignment.score, 51)
            self.assertEqual(alignment.shape, (2, 23))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.83)
            self.assertEqual(alignment.annotations["identical"], 11)
            self.assertEqual(alignment.annotations["mismatches"], 12)
            self.assertEqual(alignment.annotations["positives"], 15)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.22)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "45351")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g26815) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g26815) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 20)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  22],
                                 [207, 229]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156388828|ref|XM_001634645.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156388828|ref|XM_001634645.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156388828")
            self.assertEqual(alignment.target.annotations["gis"], "156388828")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001634645")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001634645")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001634645.1")
            self.assertEqual(alignment.target.annotations["length"], 528)
            self.assertEqual(alignment.query.annotations["start"], 207)
            self.assertEqual(alignment.query.annotations["end"], 273)
            self.assertEqual(alignment.target.annotations["start"], 306)
            self.assertEqual(alignment.target.annotations["end"], 372)
            self.assertEqual(alignment.target.seq, "RNAKVMVIFLWCLSLLSAIPPV")
            self.assertEqual(alignment.query.seq, "RNAKMTTLAMQCLQGLSTVPSI")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 25.4)
            self.assertAlmostEqual(alignment.score, 49)
            self.assertEqual(alignment.shape, (2, 22))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.91)
            self.assertEqual(alignment.annotations["identical"], 9)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.64)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "45351")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g26815) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g26815) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 19)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  23],
                                 [253, 276]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156359702|ref|XM_001624855.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156359702|ref|XM_001624855.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156359702")
            self.assertEqual(alignment.target.annotations["gis"], "156359702")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001624855")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001624855")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001624855.1")
            self.assertEqual(alignment.target.annotations["length"], 528)
            self.assertEqual(alignment.query.annotations["start"], 253)
            self.assertEqual(alignment.query.annotations["end"], 322)
            self.assertEqual(alignment.target.annotations["start"], 352)
            self.assertEqual(alignment.target.annotations["end"], 421)
            self.assertEqual(alignment.target.seq, "CQPFLRFLEWGNMDL*LPALLVL")
            self.assertEqual(alignment.query.seq, "CQPFHLFLEAGCLKFWMPSLRLL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 26.3)
            self.assertAlmostEqual(alignment.score, 51)
            self.assertEqual(alignment.shape, (2, 23))
            self.assertAlmostEqual(alignment.annotations["% identity"], 47.83)
            self.assertEqual(alignment.annotations["identical"], 11)
            self.assertEqual(alignment.annotations["mismatches"], 12)
            self.assertEqual(alignment.annotations["positives"], 15)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 65.22)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "45351")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g16273) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g16273) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 20)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  22],
                                 [207, 229]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|156359702|ref|XM_001624855.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|156359702|ref|XM_001624855.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "156359702")
            self.assertEqual(alignment.target.annotations["gis"], "156359702")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001624855")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001624855")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001624855.1")
            self.assertEqual(alignment.target.annotations["length"], 528)
            self.assertEqual(alignment.query.annotations["start"], 207)
            self.assertEqual(alignment.query.annotations["end"], 273)
            self.assertEqual(alignment.target.annotations["start"], 306)
            self.assertEqual(alignment.target.annotations["end"], 372)
            self.assertEqual(alignment.target.seq, "RNAKVMVIFLWCLSLLSAIPPV")
            self.assertEqual(alignment.query.seq, "RNAKMTTLAMQCLQGLSTVPSI")
            self.assertAlmostEqual(alignment.annotations["evalue"], 5.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 25.4)
            self.assertAlmostEqual(alignment.score, 49)
            self.assertEqual(alignment.shape, (2, 22))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.91)
            self.assertEqual(alignment.annotations["identical"], 9)
            self.assertEqual(alignment.annotations["mismatches"], 13)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 63.64)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "45351")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g16273) partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Nematostella vectensis predicted protein (NEMVEDRAFT_v1g16273) partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 19)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|471359494|ref|XM_004370266.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|471359494|ref|XM_004370266.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "471359494")
            self.assertEqual(alignment.target.annotations["gis"], "471359494")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004370266")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004370266")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004370266.1")
            self.assertEqual(alignment.target.annotations["length"], 9039)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 352)
            self.assertEqual(alignment.target.annotations["end"], 433)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "127582")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Trichechus manatus latirostris ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Trichechus manatus latirostris ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470652205|ref|XM_004329148.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470652205|ref|XM_004329148.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470652205")
            self.assertEqual(alignment.target.annotations["gis"], "470652205")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004329148")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004329148")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004329148.1")
            self.assertEqual(alignment.target.annotations["length"], 3458)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 75)
            self.assertEqual(alignment.target.annotations["end"], 156)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9739")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Tursiops truncatus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Tursiops truncatus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  36],
                                 [186, 222]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470125017|ref|XM_004298456.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470125017|ref|XM_004298456.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470125017")
            self.assertEqual(alignment.target.annotations["gis"], "470125017")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004298456")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004298456")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004298456.1")
            self.assertEqual(alignment.target.annotations["length"], 3617)
            self.assertEqual(alignment.query.annotations["start"], 186)
            self.assertEqual(alignment.query.annotations["end"], 294)
            self.assertEqual(alignment.target.annotations["start"], 1362)
            self.assertEqual(alignment.target.annotations["end"], 1470)
            self.assertEqual(
                alignment.target.seq, "FVQSCSSPNFKFSTSSSEHSQGSSNSKSIPRLRVSD"
            )
            self.assertEqual(
                alignment.query.seq, "FVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSE"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 36))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 20)
            self.assertEqual(alignment.annotations["positives"], 22)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 61.11)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "101020")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Fragaria vesca subsp. vesca cleavage and polyadenylation specificity factor subunit 3-II-like (LOC101304092), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Fragaria vesca subsp. vesca cleavage and polyadenylation specificity factor subunit 3-II-like (LOC101304092), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 31)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 31)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|466073472|ref|XM_004282882.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|466073472|ref|XM_004282882.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "466073472")
            self.assertEqual(alignment.target.annotations["gis"], "466073472")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004282882")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004282882")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004282882.1")
            self.assertEqual(alignment.target.annotations["length"], 9027)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 347)
            self.assertEqual(alignment.target.annotations["end"], 428)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9733")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Orcinus orca ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Orcinus orca ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [ 76, 113]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|449492807|ref|XM_004159059.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|449492807|ref|XM_004159059.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "449492807")
            self.assertEqual(alignment.target.annotations["gis"], "449492807")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004159059")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004159059")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004159059.1")
            self.assertEqual(alignment.target.annotations["length"], 1991)
            self.assertEqual(alignment.query.annotations["start"], 76)
            self.assertEqual(alignment.query.annotations["end"], 187)
            self.assertEqual(alignment.target.annotations["start"], 533)
            self.assertEqual(alignment.target.annotations["end"], 644)
            self.assertEqual(
                alignment.target.seq, "RLEEVSPLGSLLTGQLNRAREFIILKS*KTVRLSIEL"
            )
            self.assertEqual(
                alignment.query.seq, "RKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.54)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.16)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "3659")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 2 (LOC101210909), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 2 (LOC101210909), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [ 76, 113]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|449492804|ref|XM_004159058.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|449492804|ref|XM_004159058.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "449492804")
            self.assertEqual(alignment.target.annotations["gis"], "449492804")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004159058")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004159058")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004159058.1")
            self.assertEqual(alignment.target.annotations["length"], 2110)
            self.assertEqual(alignment.query.annotations["start"], 76)
            self.assertEqual(alignment.query.annotations["end"], 187)
            self.assertEqual(alignment.target.annotations["start"], 652)
            self.assertEqual(alignment.target.annotations["end"], 763)
            self.assertEqual(
                alignment.target.seq, "RLEEVSPLGSLLTGQLNRAREFIILKS*KTVRLSIEL"
            )
            self.assertEqual(
                alignment.query.seq, "RKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.54)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.16)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "3659")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 1 (LOC101210909), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 1 (LOC101210909), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [ 76, 113]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|449443485|ref|XM_004139460.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|449443485|ref|XM_004139460.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "449443485")
            self.assertEqual(alignment.target.annotations["gis"], "449443485")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004139460")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004139460")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004139460.1")
            self.assertEqual(alignment.target.annotations["length"], 1989)
            self.assertEqual(alignment.query.annotations["start"], 76)
            self.assertEqual(alignment.query.annotations["end"], 187)
            self.assertEqual(alignment.target.annotations["start"], 533)
            self.assertEqual(alignment.target.annotations["end"], 644)
            self.assertEqual(
                alignment.target.seq, "RLEEVSPLGSLLTGQLNRAREFIILKS*KTVRLSIEL"
            )
            self.assertEqual(
                alignment.query.seq, "RKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.54)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.16)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "3659")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 2 (LOC101210909), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 2 (LOC101210909), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [ 76, 113]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|449443483|ref|XM_004139459.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|449443483|ref|XM_004139459.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "449443483")
            self.assertEqual(alignment.target.annotations["gis"], "449443483")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004139459")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004139459")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004139459.1")
            self.assertEqual(alignment.target.annotations["length"], 2108)
            self.assertEqual(alignment.query.annotations["start"], 76)
            self.assertEqual(alignment.query.annotations["end"], 187)
            self.assertEqual(alignment.target.annotations["start"], 652)
            self.assertEqual(alignment.target.annotations["end"], 763)
            self.assertEqual(
                alignment.target.seq, "RLEEVSPLGSLLTGQLNRAREFIILKS*KTVRLSIEL"
            )
            self.assertEqual(
                alignment.query.seq, "RKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSL"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.54)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 22)
            self.assertEqual(alignment.annotations["positives"], 23)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 62.16)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "3659")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 1 (LOC101210909), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cucumis sativus uncharacterized LOC101210909, transcript variant 1 (LOC101210909), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  38],
                                 [190, 228]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|432873290|ref|XM_004072130.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|432873290|ref|XM_004072130.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "432873290")
            self.assertEqual(alignment.target.annotations["gis"], "432873290")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004072130")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004072130")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004072130.1")
            self.assertEqual(alignment.target.annotations["length"], 6378)
            self.assertEqual(alignment.query.annotations["start"], 190)
            self.assertEqual(alignment.query.annotations["end"], 304)
            self.assertEqual(alignment.target.annotations["start"], 4026)
            self.assertEqual(alignment.target.annotations["end"], 3914)
            self.assertEqual(
                alignment.target.seq, "CWLRSQGTTERRPLQMRSSADRAPSHFQMETAYLVFQM"
            )
            self.assertEqual(
                alignment.query.seq, "CWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWM"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 38))
            self.assertAlmostEqual(alignment.annotations["% identity"], 39.47)
            self.assertEqual(alignment.annotations["identical"], 15)
            self.assertEqual(alignment.annotations["mismatches"], 23)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/-3")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "-3")
            self.assertEqual(alignment.target.annotations["tax ids"], "8090")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Oryzias latipes zinc finger protein 462-like (LOC101161246), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Oryzias latipes zinc finger protein 462-like (LOC101161246), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 33)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 33)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|426392076|ref|XM_004062338.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|426392076|ref|XM_004062338.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "426392076")
            self.assertEqual(alignment.target.annotations["gis"], "426392076")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004062338")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004062338")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004062338.1")
            self.assertEqual(alignment.target.annotations["length"], 9002)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 345)
            self.assertEqual(alignment.target.annotations["end"], 426)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9595")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Gorilla gorilla gorilla ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Gorilla gorilla gorilla ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410953779|ref|XM_003983499.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410953779|ref|XM_003983499.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410953779")
            self.assertEqual(alignment.target.annotations["gis"], "410953779")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003983499")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003983499")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003983499.1")
            self.assertEqual(alignment.target.annotations["length"], 6297)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 129)
            self.assertEqual(alignment.target.annotations["end"], 210)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9685")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Felis catus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Felis catus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|403282318|ref|XM_003932550.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|403282318|ref|XM_003932550.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "403282318")
            self.assertEqual(alignment.target.annotations["gis"], "403282318")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003932550")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003932550")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003932550.1")
            self.assertEqual(alignment.target.annotations["length"], 7122)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 378)
            self.assertEqual(alignment.target.annotations["end"], 459)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "39432")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Saimiri boliviensis boliviensis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Saimiri boliviensis boliviensis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|402882302|ref|XM_003904638.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|402882302|ref|XM_003904638.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "402882302")
            self.assertEqual(alignment.target.annotations["gis"], "402882302")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003904638")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003904638")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003904638.1")
            self.assertEqual(alignment.target.annotations["length"], 9027)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 378)
            self.assertEqual(alignment.target.annotations["end"], 459)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9555")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Papio anubis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Papio anubis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|397475827|ref|XM_003809272.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|397475827|ref|XM_003809272.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "397475827")
            self.assertEqual(alignment.target.annotations["gis"], "397475827")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003809272")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003809272")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003809272.1")
            self.assertEqual(alignment.target.annotations["length"], 8939)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 282)
            self.assertEqual(alignment.target.annotations["end"], 363)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9597")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan paniscus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan paniscus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|395752429|ref|XM_002830404.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|395752429|ref|XM_002830404.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "395752429")
            self.assertEqual(alignment.target.annotations["gis"], "395752429")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002830404")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002830404")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002830404.2")
            self.assertEqual(alignment.target.annotations["length"], 5544)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 345)
            self.assertEqual(alignment.target.annotations["end"], 426)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9601")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pongo abelii ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pongo abelii ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|395506884|ref|XM_003757711.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|395506884|ref|XM_003757711.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "395506884")
            self.assertEqual(alignment.target.annotations["gis"], "395506884")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003757711")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003757711")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003757711.1")
            self.assertEqual(alignment.target.annotations["length"], 5767)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 153)
            self.assertEqual(alignment.target.annotations["end"], 234)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9305")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sarcophilus harrisii ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sarcophilus harrisii ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363741618|ref|XM_417388.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363741618|ref|XM_417388.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363741618")
            self.assertEqual(alignment.target.annotations["gis"], "363741618")
            self.assertEqual(alignment.target.annotations["acc."], "XM_417388")
            self.assertEqual(alignment.target.annotations["accs."], "XM_417388")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_417388.3")
            self.assertEqual(alignment.target.annotations["length"], 5934)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 313)
            self.assertEqual(alignment.target.annotations["end"], 394)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/2")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9031")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Gallus gallus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Gallus gallus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|359322761|ref|XM_534448.4|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|359322761|ref|XM_534448.4|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "359322761")
            self.assertEqual(alignment.target.annotations["gis"], "359322761")
            self.assertEqual(alignment.target.annotations["acc."], "XM_534448")
            self.assertEqual(alignment.target.annotations["accs."], "XM_534448")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_534448.4")
            self.assertEqual(alignment.target.annotations["length"], 6505)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 353)
            self.assertEqual(alignment.target.annotations["end"], 434)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9615")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Canis lupus familiaris ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Canis lupus familiaris ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|354476751|ref|XM_003500539.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|354476751|ref|XM_003500539.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "354476751")
            self.assertEqual(alignment.target.annotations["gis"], "354476751")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003500539")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003500539")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003500539.1")
            self.assertEqual(alignment.target.annotations["length"], 6829)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 207)
            self.assertEqual(alignment.target.annotations["end"], 288)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "10029")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cricetulus griseus brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100773989), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cricetulus griseus brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100773989), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|350595022|ref|XM_003483981.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350595022|ref|XM_003483981.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "350595022")
            self.assertEqual(alignment.target.annotations["gis"], "350595022")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003483981")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003483981")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003483981.1")
            self.assertEqual(alignment.target.annotations["length"], 6052)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 351)
            self.assertEqual(alignment.target.annotations["end"], 432)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9823")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sus scrofa ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sus scrofa ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|350591776|ref|XM_003132566.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350591776|ref|XM_003132566.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "350591776")
            self.assertEqual(alignment.target.annotations["gis"], "350591776")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003132566")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003132566")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003132566.3")
            self.assertEqual(alignment.target.annotations["length"], 1870)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 1159)
            self.assertEqual(alignment.target.annotations["end"], 1219)
            self.assertEqual(alignment.target.seq, "AGRVDFWMPGLRLWPRRWRF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9823")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sus scrofa ephrin type-B receptor 3-like (LOC100514541), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sus scrofa ephrin type-B receptor 3-like (LOC100514541), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|350591772|ref|XM_003358733.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350591772|ref|XM_003358733.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "350591772")
            self.assertEqual(alignment.target.annotations["gis"], "350591772")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003358733")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003358733")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003358733.2")
            self.assertEqual(alignment.target.annotations["length"], 3776)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 3064)
            self.assertEqual(alignment.target.annotations["end"], 3124)
            self.assertEqual(alignment.target.seq, "AGRVDFWMPGLRLWPRRWRF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9823")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sus scrofa EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sus scrofa EPH receptor B3, transcript variant 2 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|348563932|ref|XM_003467713.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|348563932|ref|XM_003467713.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "348563932")
            self.assertEqual(alignment.target.annotations["gis"], "348563932")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003467713")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003467713")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003467713.1")
            self.assertEqual(alignment.target.annotations["length"], 5355)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "10141")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Cavia porcellus brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100724838), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Cavia porcellus brefeldin A-inhibited guanine nucleotide-exchange protein 2-like (LOC100724838), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|344280063|ref|XM_003411757.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|344280063|ref|XM_003411757.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "344280063")
            self.assertEqual(alignment.target.annotations["gis"], "344280063")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003411757")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003411757")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003411757.1")
            self.assertEqual(alignment.target.annotations["length"], 5452)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9785")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Loxodonta africana ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Loxodonta africana ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|338719107|ref|XM_001916930.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|338719107|ref|XM_001916930.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "338719107")
            self.assertEqual(alignment.target.annotations["gis"], "338719107")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001916930")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001916930")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001916930.2")
            self.assertEqual(alignment.target.annotations["length"], 5782)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 342)
            self.assertEqual(alignment.target.annotations["end"], 423)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9796")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Equus caballus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Equus caballus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  20],
                                 [280, 300]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|335300059|ref|XM_003132565.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|335300059|ref|XM_003132565.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "335300059")
            self.assertEqual(alignment.target.annotations["gis"], "335300059")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003132565")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003132565")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003132565.2")
            self.assertEqual(alignment.target.annotations["length"], 3667)
            self.assertEqual(alignment.query.annotations["start"], 280)
            self.assertEqual(alignment.query.annotations["end"], 340)
            self.assertEqual(alignment.target.annotations["start"], 2956)
            self.assertEqual(alignment.target.annotations["end"], 3016)
            self.assertEqual(alignment.target.seq, "AGRVDFWMPGLRLWPRRWRF")
            self.assertEqual(alignment.query.seq, "AGCLKFWMPSLRLLISRWRF")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 20))
            self.assertAlmostEqual(alignment.annotations["% identity"], 65.00)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 7)
            self.assertEqual(alignment.annotations["positives"], 14)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.00)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "2/2")
            self.assertEqual(alignment.query.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["frame"], "2")
            self.assertEqual(alignment.target.annotations["tax ids"], "9823")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sus scrofa EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sus scrofa EPH receptor B3, transcript variant 1 (EPHB3), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 17)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 17)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|334312365|ref|XM_001379067.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|334312365|ref|XM_001379067.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "334312365")
            self.assertEqual(alignment.target.annotations["gis"], "334312365")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001379067")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001379067")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001379067.2")
            self.assertEqual(alignment.target.annotations["length"], 5511)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "13616")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Monodelphis domestica ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Monodelphis domestica ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332858727|ref|XM_001165517.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332858727|ref|XM_001165517.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332858727")
            self.assertEqual(alignment.target.annotations["gis"], "332858727")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001165517")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001165517")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001165517.2")
            self.assertEqual(alignment.target.annotations["length"], 8850)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 1 (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 1 (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332207745|ref|XM_003252909.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332207745|ref|XM_003252909.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332207745")
            self.assertEqual(alignment.target.annotations["gis"], "332207745")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003252909")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003252909")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003252909.1")
            self.assertEqual(alignment.target.annotations["length"], 9022)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 369)
            self.assertEqual(alignment.target.annotations["end"], 450)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "61853")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Nomascus leucogenys ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 2 (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Nomascus leucogenys ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 2 (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|332207743|ref|XM_003252908.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|332207743|ref|XM_003252908.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "332207743")
            self.assertEqual(alignment.target.annotations["gis"], "332207743")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003252908")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003252908")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003252908.1")
            self.assertEqual(alignment.target.annotations["length"], 9031)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 369)
            self.assertEqual(alignment.target.annotations["end"], 450)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "61853")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Nomascus leucogenys ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 1 (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Nomascus leucogenys ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 1 (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|326931872|ref|XM_003212000.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|326931872|ref|XM_003212000.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "326931872")
            self.assertEqual(alignment.target.annotations["gis"], "326931872")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003212000")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003212000")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003212000.1")
            self.assertEqual(alignment.target.annotations["length"], 5240)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 80)
            self.assertEqual(alignment.target.annotations["end"], 161)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9103")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Meleagris gallopavo ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Meleagris gallopavo ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|327271833|ref|XM_003220644.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|327271833|ref|XM_003220644.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "327271833")
            self.assertEqual(alignment.target.annotations["gis"], "327271833")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003220644")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003220644")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003220644.1")
            self.assertEqual(alignment.target.annotations["length"], 5379)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 219)
            self.assertEqual(alignment.target.annotations["end"], 300)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "28377")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Anolis carolinensis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Anolis carolinensis ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (arfgef2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|301754408|ref|XM_002912990.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|301754408|ref|XM_002912990.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "301754408")
            self.assertEqual(alignment.target.annotations["gis"], "301754408")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002912990")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002912990")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002912990.1")
            self.assertEqual(alignment.target.annotations["length"], 6451)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9646")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Ailuropoda melanoleuca ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Ailuropoda melanoleuca ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|297259620|ref|XM_002798127.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|297259620|ref|XM_002798127.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "297259620")
            self.assertEqual(alignment.target.annotations["gis"], "297259620")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002798127")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002798127")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002798127.1")
            self.assertEqual(alignment.target.annotations["length"], 5801)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 378)
            self.assertEqual(alignment.target.annotations["end"], 459)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9544")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Macaca mulatta ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Macaca mulatta ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|296200663|ref|XM_002806776.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|296200663|ref|XM_002806776.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "296200663")
            self.assertEqual(alignment.target.annotations["gis"], "296200663")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002806776")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002806776")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002806776.1")
            self.assertEqual(alignment.target.annotations["length"], 5612)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 240)
            self.assertEqual(alignment.target.annotations["end"], 321)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9483")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Callithrix jacchus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Callithrix jacchus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|242009078|ref|XM_002425275.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|242009078|ref|XM_002425275.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "242009078")
            self.assertEqual(alignment.target.annotations["gis"], "242009078")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002425275")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002425275")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002425275.1")
            self.assertEqual(alignment.target.annotations["length"], 5343)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 225)
            self.assertEqual(alignment.target.annotations["end"], 306)
            self.assertEqual(alignment.target.seq, "YFLPFELVCQSKSSRIVVTALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "121224")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Pediculus humanus corporis Brefeldin A-inhibited guanine nucleotide-exchange protein, putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Pediculus humanus corporis Brefeldin A-inhibited guanine nucleotide-exchange protein, putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|224078727|ref|XM_002187178.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|224078727|ref|XM_002187178.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "224078727")
            self.assertEqual(alignment.target.annotations["gis"], "224078727")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002187178")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002187178")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002187178.1")
            self.assertEqual(alignment.target.annotations["length"], 5406)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 219)
            self.assertEqual(alignment.target.annotations["end"], 300)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "59729")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Taeniopygia guttata ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Taeniopygia guttata ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|167736368|ref|NM_001085495.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|167736368|ref|NM_001085495.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "167736368")
            self.assertEqual(alignment.target.annotations["gis"], "167736368")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001085495")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001085495")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001085495.2")
            self.assertEqual(alignment.target.annotations["length"], 8777)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 335)
            self.assertEqual(alignment.target.annotations["end"], 416)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "10090")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Mus musculus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Mus musculus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|150417985|ref|NM_006420.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|150417985|ref|NM_006420.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "150417985")
            self.assertEqual(alignment.target.annotations["gis"], "150417985")
            self.assertEqual(alignment.target.annotations["acc."], "NM_006420")
            self.assertEqual(alignment.target.annotations["accs."], "NM_006420")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_006420.2")
            self.assertEqual(alignment.target.annotations["length"], 9004)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 353)
            self.assertEqual(alignment.target.annotations["end"], 434)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9606")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Homo sapiens ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Homo sapiens ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|149639802|ref|XM_001506842.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|149639802|ref|XM_001506842.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "149639802")
            self.assertEqual(alignment.target.annotations["gis"], "149639802")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001506842")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001506842")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001506842.1")
            self.assertEqual(alignment.target.annotations["length"], 5268)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 105)
            self.assertEqual(alignment.target.annotations["end"], 186)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9258")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Ornithorhynchus anatinus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Ornithorhynchus anatinus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|114682530|ref|XM_001165584.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|114682530|ref|XM_001165584.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "114682530")
            self.assertEqual(alignment.target.annotations["gis"], "114682530")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001165584")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001165584")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001165584.1")
            self.assertEqual(alignment.target.annotations["length"], 8859)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 3 (ARFGEF2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited), transcript variant 3 (ARFGEF2), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|31342050|ref|NM_181083.2|")
            self.assertEqual(
                alignment.target.annotations["ids"],
                "gi|31342050|ref|NM_181083.2|;gi|31126987|gb|AY255526.2|",
            )
            self.assertEqual(alignment.target.annotations["gi"], "31342050")
            self.assertEqual(alignment.target.annotations["gis"], "31342050;31126987")
            self.assertEqual(alignment.target.annotations["acc."], "NM_181083")
            self.assertEqual(
                alignment.target.annotations["accs."], "NM_181083;AY255526"
            )
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_181083.2")
            self.assertEqual(alignment.target.annotations["length"], 5784)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 201)
            self.assertEqual(alignment.target.annotations["end"], 282)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRVVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 6.4)
            self.assertAlmostEqual(alignment.annotations["bit score"], 35.0)
            self.assertAlmostEqual(alignment.score, 70)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 74.07)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "10116")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Rattus norvegicus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Rattus norvegicus ADP-ribosylation factor guanine nucleotide-exchange factor 2 (brefeldin A-inhibited) (Arfgef2), mRNA<>Rattus norvegicus Brefeldin A-inhibited guanine nucleotide-exchange factor 2 (Big2) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [135, 190]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410036861|ref|XM_001150377.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410036861|ref|XM_001150377.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410036861")
            self.assertEqual(alignment.target.annotations["gis"], "410036861")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001150377")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001150377")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001150377.3")
            self.assertEqual(alignment.target.annotations["length"], 3555)
            self.assertEqual(alignment.query.annotations["start"], 135)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 660)
            self.assertEqual(alignment.target.annotations["end"], 825)
            self.assertEqual(
                alignment.target.seq,
                "RVHLSPLRQLWPGSSQPAVFPVQIKDSSPTCVACVRGQGKTTVPSPPRNRTSATL",
            )
            self.assertEqual(
                alignment.query.seq,
                "RVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.36)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.91)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes lactotransferrin, transcript variant 3 (LTF), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes lactotransferrin, transcript variant 3 (LTF), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [135, 190]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|410036860|ref|XM_516417.4|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|410036860|ref|XM_516417.4|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "410036860")
            self.assertEqual(alignment.target.annotations["gis"], "410036860")
            self.assertEqual(alignment.target.annotations["acc."], "XM_516417")
            self.assertEqual(alignment.target.annotations["accs."], "XM_516417")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_516417.4")
            self.assertEqual(alignment.target.annotations["length"], 3660)
            self.assertEqual(alignment.query.annotations["start"], 135)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 765)
            self.assertEqual(alignment.target.annotations["end"], 930)
            self.assertEqual(
                alignment.target.seq,
                "RVHLSPLRQLWPGSSQPAVFPVQIKDSSPTCVACVRGQGKTTVPSPPRNRTSATL",
            )
            self.assertEqual(
                alignment.query.seq,
                "RVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.36)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.91)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9598")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan troglodytes lactotransferrin, transcript variant 8 (LTF), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan troglodytes lactotransferrin, transcript variant 8 (LTF), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [135, 190]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|397495317|ref|XM_003818457.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|397495317|ref|XM_003818457.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "397495317")
            self.assertEqual(alignment.target.annotations["gis"], "397495317")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003818457")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003818457")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003818457.1")
            self.assertEqual(alignment.target.annotations["length"], 2515)
            self.assertEqual(alignment.query.annotations["start"], 135)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 660)
            self.assertEqual(alignment.target.annotations["end"], 825)
            self.assertEqual(
                alignment.target.seq,
                "RVHLSPLRQLWPGSSQPAVFPVQIKDSSPTCVACVRGQGKTTVPSPPRNRTSATL",
            )
            self.assertEqual(
                alignment.query.seq,
                "RVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.36)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.91)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9597")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan paniscus lactotransferrin, transcript variant 2 (LTF), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan paniscus lactotransferrin, transcript variant 2 (LTF), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  55],
                                 [135, 190]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|397495315|ref|XM_003818456.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|397495315|ref|XM_003818456.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "397495315")
            self.assertEqual(alignment.target.annotations["gis"], "397495315")
            self.assertEqual(alignment.target.annotations["acc."], "XM_003818456")
            self.assertEqual(alignment.target.annotations["accs."], "XM_003818456")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_003818456.1")
            self.assertEqual(alignment.target.annotations["length"], 2620)
            self.assertEqual(alignment.query.annotations["start"], 135)
            self.assertEqual(alignment.query.annotations["end"], 300)
            self.assertEqual(alignment.target.annotations["start"], 765)
            self.assertEqual(alignment.target.annotations["end"], 930)
            self.assertEqual(
                alignment.target.seq,
                "RVHLSPLRQLWPGSSQPAVFPVQIKDSSPTCVACVRGQGKTTVPSPPRNRTSATL",
            )
            self.assertEqual(
                alignment.query.seq,
                "RVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEIL",
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 55))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.36)
            self.assertEqual(alignment.annotations["identical"], 20)
            self.assertEqual(alignment.annotations["mismatches"], 35)
            self.assertEqual(alignment.annotations["positives"], 28)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 50.91)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9597")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Pan paniscus lactotransferrin, transcript variant 1 (LTF), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Pan paniscus lactotransferrin, transcript variant 1 (LTF), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 47)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 47)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|392887648|ref|NM_001026628.3|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|392887648|ref|NM_001026628.3|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "392887648")
            self.assertEqual(alignment.target.annotations["gis"], "392887648")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001026628")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001026628")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001026628.3")
            self.assertEqual(alignment.target.annotations["length"], 1656)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 234)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(alignment.target.seq, "YFLPFELACNSKSPKIVITALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "6239")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Caenorhabditis elegans Protein AGEF-1, isoform b (agef-1) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Caenorhabditis elegans Protein AGEF-1, isoform b (agef-1) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|392887646|ref|NM_001026627.5|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|392887646|ref|NM_001026627.5|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "392887646")
            self.assertEqual(alignment.target.annotations["gis"], "392887646")
            self.assertEqual(alignment.target.annotations["acc."], "NM_001026627")
            self.assertEqual(alignment.target.annotations["accs."], "NM_001026627")
            self.assertEqual(alignment.target.annotations["acc.ver"], "NM_001026627.5")
            self.assertEqual(alignment.target.annotations["length"], 4785)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 234)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(alignment.target.seq, "YFLPFELACNSKSPKIVITALDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 18)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 66.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "6239")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Caenorhabditis elegans Protein AGEF-1, isoform a",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Caenorhabditis elegans Protein AGEF-1, isoform a",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  43],
                                 [131,  88]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|363727654|ref|XM_001235329.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|363727654|ref|XM_001235329.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "363727654")
            self.assertEqual(alignment.target.annotations["gis"], "363727654")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001235329")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001235329")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001235329.2")
            self.assertEqual(alignment.target.annotations["length"], 8058)
            self.assertEqual(alignment.query.annotations["start"], 130)
            self.assertEqual(alignment.query.annotations["end"], 3)
            self.assertEqual(alignment.target.annotations["start"], 1805)
            self.assertEqual(alignment.target.annotations["end"], 1934)
            self.assertEqual(
                alignment.target.seq, "NIGTMWNLQWEFKR*FSFSSRDDRRDPATSCQCMEGFLSLFCA"
            )
            self.assertEqual(
                alignment.query.seq, "NISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPPVFMA"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 43))
            self.assertAlmostEqual(alignment.annotations["% identity"], 37.21)
            self.assertEqual(alignment.annotations["identical"], 16)
            self.assertEqual(alignment.annotations["mismatches"], 27)
            self.assertEqual(alignment.annotations["positives"], 20)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 46.51)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/3")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9031")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Gallus gallus otogelin-like (LOC772154), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Gallus gallus otogelin-like (LOC772154), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 37)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 37)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|350583133|ref|XM_001928010.4|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|350583133|ref|XM_001928010.4|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "350583133")
            self.assertEqual(alignment.target.annotations["gis"], "350583133")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001928010")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001928010")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001928010.4")
            self.assertEqual(alignment.target.annotations["length"], 7207)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 584)
            self.assertEqual(alignment.target.annotations["end"], 665)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRCPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/3")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "9823")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Sus scrofa guanine nucleotide-exchange protein (LOC100156861), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Sus scrofa guanine nucleotide-exchange protein (LOC100156861), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|345486369|ref|XM_001605920.2|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|345486369|ref|XM_001605920.2|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "345486369")
            self.assertEqual(alignment.target.annotations["gis"], "345486369")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001605920")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001605920")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001605920.2")
            self.assertEqual(alignment.target.annotations["length"], 7150)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 234)
            self.assertEqual(alignment.target.annotations["end"], 315)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSKSPRIVVTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 44.44)
            self.assertEqual(alignment.annotations["identical"], 12)
            self.assertEqual(alignment.annotations["mismatches"], 15)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7425")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Nasonia vitripennis brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100122365), mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Nasonia vitripennis brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100122365), mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|344272888|ref|XR_133687.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|344272888|ref|XR_133687.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "344272888")
            self.assertEqual(alignment.target.annotations["gis"], "344272888")
            self.assertEqual(alignment.target.annotations["acc."], "XR_133687")
            self.assertEqual(alignment.target.annotations["accs."], "XR_133687")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XR_133687.1")
            self.assertEqual(alignment.target.annotations["length"], 5928)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 237)
            self.assertEqual(alignment.target.annotations["end"], 318)
            self.assertEqual(alignment.target.seq, "YFLPFELACQSRCPRIVSTSLDCLQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 48.15)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 14)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "9785")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "PREDICTED: Loxodonta africana brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100676028), miscRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "PREDICTED: Loxodonta africana brefeldin A-inhibited guanine nucleotide-exchange protein 1-like (LOC100676028), miscRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  27],
                                 [174, 201]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|241632443|ref|XM_002408552.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|241632443|ref|XM_002408552.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "241632443")
            self.assertEqual(alignment.target.annotations["gis"], "241632443")
            self.assertEqual(alignment.target.annotations["acc."], "XM_002408552")
            self.assertEqual(alignment.target.annotations["accs."], "XM_002408552")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_002408552.1")
            self.assertEqual(alignment.target.annotations["length"], 4938)
            self.assertEqual(alignment.query.annotations["start"], 174)
            self.assertEqual(alignment.query.annotations["end"], 255)
            self.assertEqual(alignment.target.annotations["start"], 231)
            self.assertEqual(alignment.target.annotations["end"], 312)
            self.assertEqual(alignment.target.seq, "YLMPFELACQSKSPRIVVTALDCIQKL")
            self.assertEqual(alignment.query.seq, "FALPFVLACQSRNAKMTTLAMQCLQGL")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 27))
            self.assertAlmostEqual(alignment.annotations["% identity"], 40.74)
            self.assertEqual(alignment.annotations["identical"], 11)
            self.assertEqual(alignment.annotations["mismatches"], 16)
            self.assertEqual(alignment.annotations["positives"], 19)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 70.37)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "6945")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Ixodes scapularis brefeldin A-inhibited guanine nucleotide-exchange protein, putative, mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Ixodes scapularis brefeldin A-inhibited guanine nucleotide-exchange protein, putative, mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 23)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 23)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [201, 238]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|157129065|ref|XM_001655210.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|157129065|ref|XM_001655210.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "157129065")
            self.assertEqual(alignment.target.annotations["gis"], "157129065")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001655210")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001655210")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001655210.1")
            self.assertEqual(alignment.target.annotations["length"], 3194)
            self.assertEqual(alignment.query.annotations["start"], 201)
            self.assertEqual(alignment.query.annotations["end"], 312)
            self.assertEqual(alignment.target.annotations["start"], 1116)
            self.assertEqual(alignment.target.annotations["end"], 1227)
            self.assertEqual(
                alignment.target.seq, "QAYNMSVTDLAIKSIQGIASLHTLPRSRAIIAFQAFV"
            )
            self.assertEqual(
                alignment.query.seq, "QSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFI"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.14)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 25)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.57)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7159")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aedes aegypti hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aedes aegypti hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  37],
                                 [201, 238]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|157129063|ref|XM_001655209.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|157129063|ref|XM_001655209.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "157129063")
            self.assertEqual(alignment.target.annotations["gis"], "157129063")
            self.assertEqual(alignment.target.annotations["acc."], "XM_001655209")
            self.assertEqual(alignment.target.annotations["accs."], "XM_001655209")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_001655209.1")
            self.assertEqual(alignment.target.annotations["length"], 3108)
            self.assertEqual(alignment.query.annotations["start"], 201)
            self.assertEqual(alignment.query.annotations["end"], 312)
            self.assertEqual(alignment.target.annotations["start"], 1116)
            self.assertEqual(alignment.target.annotations["end"], 1227)
            self.assertEqual(
                alignment.target.seq, "QAYNMSVTDLAIKSIQGIASLHTLPRSRAIIAFQAFV"
            )
            self.assertEqual(
                alignment.query.seq, "QSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFI"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.7)
            self.assertAlmostEqual(alignment.annotations["bit score"], 34.5)
            self.assertAlmostEqual(alignment.score, 69)
            self.assertEqual(alignment.shape, (2, 37))
            self.assertAlmostEqual(alignment.annotations["% identity"], 35.14)
            self.assertEqual(alignment.annotations["identical"], 13)
            self.assertEqual(alignment.annotations["mismatches"], 24)
            self.assertEqual(alignment.annotations["positives"], 25)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 67.57)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "1/1")
            self.assertEqual(alignment.query.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "7159")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Aedes aegypti hypothetical protein partial mRNA",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Aedes aegypti hypothetical protein partial mRNA",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 32)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 32)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  30],
                                 [214, 184]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470250072|ref|XM_004367211.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470250072|ref|XM_004367211.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470250072")
            self.assertEqual(alignment.target.annotations["gis"], "470250072")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004367211")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004367211")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004367211.1")
            self.assertEqual(alignment.target.annotations["length"], 1509)
            self.assertEqual(alignment.query.annotations["start"], 213)
            self.assertEqual(alignment.query.annotations["end"], 125)
            self.assertEqual(alignment.target.annotations["start"], 1083)
            self.assertEqual(alignment.target.annotations["end"], 1173)
            self.assertEqual(alignment.target.seq, "HSQIGNPSTNNNNNQNLITQPQNYEMYKIN")
            self.assertEqual(alignment.query.seq, "HSLIGKPTRKGVRNPDVFLAPQNYVLFSIS")
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 31.3)
            self.assertAlmostEqual(alignment.score, 62)
            self.assertEqual(alignment.shape, (2, 30))
            self.assertAlmostEqual(alignment.annotations["% identity"], 36.67)
            self.assertEqual(alignment.annotations["identical"], 11)
            self.assertEqual(alignment.annotations["mismatches"], 19)
            self.assertEqual(alignment.annotations["positives"], 17)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 56.67)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-2/1")
            self.assertEqual(alignment.query.annotations["frame"], "-2")
            self.assertEqual(alignment.target.annotations["frame"], "1")
            self.assertEqual(alignment.target.annotations["tax ids"], "261658")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Dictyostelium fasciculatum hypothetical protein (DFA_07408) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Dictyostelium fasciculatum hypothetical protein (DFA_07408) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 55)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 26)
            alignment = next(alignments)
            self.assertTrue(
                numpy.array_equal(
                    alignment.coordinates,
                    # fmt: off
# flake8: noqa
                    numpy.array([[  0,  38],
                                 [137,  99]])
                    # fmt: on
                )
            )
            self.assertEqual(alignment.query.id, "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.description,
                "Saccharomyces cerevisiae S288c Mon2p (MON2) mRNA, complete cds",
            )
            self.assertEqual(alignment.query.annotations["gi"], "0")
            self.assertEqual(alignment.query.annotations["acc."], "gi|296147483:1-350")
            self.assertEqual(
                alignment.query.annotations["acc.ver"], "gi|296147483:1-350"
            )
            self.assertEqual(alignment.target.id, "gi|470250072|ref|XM_004367211.1|")
            self.assertEqual(
                alignment.target.annotations["ids"], "gi|470250072|ref|XM_004367211.1|"
            )
            self.assertEqual(alignment.target.annotations["gi"], "470250072")
            self.assertEqual(alignment.target.annotations["gis"], "470250072")
            self.assertEqual(alignment.target.annotations["acc."], "XM_004367211")
            self.assertEqual(alignment.target.annotations["accs."], "XM_004367211")
            self.assertEqual(alignment.target.annotations["acc.ver"], "XM_004367211.1")
            self.assertEqual(alignment.target.annotations["length"], 1509)
            self.assertEqual(alignment.query.annotations["start"], 136)
            self.assertEqual(alignment.query.annotations["end"], 24)
            self.assertEqual(alignment.target.annotations["start"], 1298)
            self.assertEqual(alignment.target.annotations["end"], 1412)
            self.assertEqual(
                alignment.target.seq, "LFQEKTSLS*LWKVILFTML*SPSHCTRLPTQCPCLRS"
            )
            self.assertEqual(
                alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMES"
            )
            self.assertAlmostEqual(alignment.annotations["evalue"], 8.8)
            self.assertAlmostEqual(alignment.annotations["bit score"], 22.1)
            self.assertAlmostEqual(alignment.score, 42)
            self.assertEqual(alignment.shape, (2, 38))
            self.assertAlmostEqual(alignment.annotations["% identity"], 26.32)
            self.assertEqual(alignment.annotations["identical"], 10)
            self.assertEqual(alignment.annotations["mismatches"], 28)
            self.assertEqual(alignment.annotations["positives"], 16)
            self.assertEqual(alignment.annotations["gap opens"], 0)
            self.assertEqual(alignment.annotations["gaps"], 0)
            self.assertAlmostEqual(alignment.annotations["% positives"], 42.11)
            self.assertEqual(alignment.annotations["query/sbjct frames"], "-1/3")
            self.assertEqual(alignment.query.annotations["frame"], "-1")
            self.assertEqual(alignment.target.annotations["frame"], "3")
            self.assertEqual(alignment.target.annotations["tax ids"], "261658")
            self.assertEqual(alignment.target.annotations["sci names"], "N/A")
            self.assertEqual(alignment.target.annotations["com names"], "N/A")
            self.assertEqual(alignment.target.annotations["blast names"], "N/A")
            self.assertEqual(alignment.target.annotations["super kingdoms"], "N/A")
            self.assertEqual(
                alignment.target.annotations["title"],
                "Dictyostelium fasciculatum hypothetical protein (DFA_07408) mRNA, complete cds",
            )
            self.assertEqual(
                alignment.target.annotations["titles"],
                "Dictyostelium fasciculatum hypothetical protein (DFA_07408) mRNA, complete cds",
            )
            self.assertEqual(alignment.target.annotations["strand"], "N/A")
            self.assertAlmostEqual(alignment.target.annotations["% coverage"], 55)
            self.assertAlmostEqual(alignment.annotations["% hsp coverage"], 33)
            with self.assertRaises(StopIteration):
                next(alignments)


if __name__ == "__main__":
    runner = unittest.TextTestRunner(verbosity=2)
    unittest.main(testRunner=runner)
