mirror of
https://github.com/biopython/biopython.git
synced 2025-10-20 21:53:47 +08:00
Fix assertAlmostEqual calls in tests, when checking for very small numbers in scientific notation. (#4770)
Fix assertAlmostEqual calls in tests, when checking for very small numbers in scientific notation by adding "places" parameter with enough precision. This mostly affects comparing E-values between test files and parsing of those files. Quite some cases were actually checking for the wrong value.
This commit is contained in:
Gert Hulselmans
GitHub
3
NEWS.rst
3
NEWS.rst
@ -21,6 +21,9 @@ life, our support for it is now deprecated.
|
||||
Predictor and reading motifs in ``pfm-four-columns`` format will set motif name
|
||||
to "" instead of None, when no motif name was found.
|
||||
|
||||
Tests that use assertAlmostEqual calls now use ``places`` parameter with enough
|
||||
presision when comparing very small numbers in scientific notation.
|
||||
|
||||
Many thanks to the Biopython developers and community for making this release
|
||||
possible, especially the following contributors:
|
||||
|
||||
|
||||
@ -38,7 +38,7 @@ class Align_hhr_2uvo_hhblits(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.95)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.7e-34)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.7e-34, places=35)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 210.31)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 2.050)
|
||||
@ -148,7 +148,7 @@ np.array([['E', 'R', 'C', 'G', 'E', 'Q', 'G', 'S', 'N', 'M', 'E', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.92)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-30)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-30, places=31)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 190.44)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 49)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.254)
|
||||
@ -257,7 +257,7 @@ np.array([['G', 'X', 'G', 'C', 'X', 'G', 'X', 'X', 'M', 'Y', 'C', 'S', 'T',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.77)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.2e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.2e-24, places=25)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 148.19)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 50)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.303)
|
||||
@ -359,7 +359,7 @@ np.array([['P', 'V', 'C', 'G', 'V', 'R', 'A', 'S', 'G', 'R', 'V', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.77)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-24, places=25)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 147.59)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 52)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.251)
|
||||
@ -461,7 +461,7 @@ np.array([['P', 'V', 'C', 'G', 'V', 'R', 'A', 'S', 'G', 'R', 'V', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.72)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.7e-23)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.7e-23, places=24)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 148.46)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 61)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.542)
|
||||
@ -563,7 +563,7 @@ np.array([['R', 'C', 'G', 'E', 'Q', 'G', 'S', 'N', 'M', 'E', 'C', 'P', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.66)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.4e-21)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.4e-21, places=22)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 140.12)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 41)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.182)
|
||||
@ -661,7 +661,7 @@ np.array([['X', 'G', 'C', 'X', 'G', 'X', 'X', 'M', 'Y', 'C', 'S', 'T', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.31)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-16, places=17)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 102.02)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 47)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.275)
|
||||
@ -753,7 +753,7 @@ np.array([['P', 'E', 'C', 'G', 'E', 'R', 'A', 'S', 'G', 'K', 'R', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.26)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.7e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.7e-16, places=17)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 101.24)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 47)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.259)
|
||||
@ -845,7 +845,7 @@ np.array([['E', 'R', 'C', 'G', 'S', 'Q', 'G', 'G', 'G', 'S', 'T', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.22)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7.4e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7.4e-16, places=17)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 99.76)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 47)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.232)
|
||||
@ -937,7 +937,7 @@ np.array([['R', 'C', 'G', 'S', 'Q', 'G', 'G', 'G', 'S', 'T', 'C', 'P', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.21)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.6e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.6e-16, places=17)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 97.65)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 54)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.333)
|
||||
@ -1029,7 +1029,7 @@ np.array([['E', 'C', 'G', 'E', 'R', 'A', 'S', 'G', 'K', 'R', 'C', 'P', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.79)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7.7e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7.7e-09, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 56.76)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 68)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.600)
|
||||
@ -1102,7 +1102,7 @@ np.array([['Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'K', 'L', 'C', 'P', 'D',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.67)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.9e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.9e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 54.61)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 46)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.182)
|
||||
@ -1175,7 +1175,7 @@ np.array([['E', 'T', 'C', 'A', 'S', '-', 'R', 'C', 'P', 'R', 'P', 'C', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.66)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.9e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.9e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 54.54)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 42)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.206)
|
||||
@ -1248,7 +1248,7 @@ np.array([['T', 'C', 'A', 'S', '-', 'R', 'C', 'P', 'R', 'P', 'C', 'N', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.65)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 54.99)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 50)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.302)
|
||||
@ -1322,7 +1322,7 @@ np.array([['E', 'Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'K', 'L', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.62)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.4e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.4e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 55.16)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 51)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.325)
|
||||
@ -1395,7 +1395,7 @@ np.array([['Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'A', 'L', 'C', 'P', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.59)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 54.44)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 59)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.493)
|
||||
@ -1468,7 +1468,7 @@ np.array([['R', 'C', 'G', 'D', 'Q', 'A', 'R', 'G', 'A', 'K', 'C', 'P', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.57)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.3e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.3e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 54.59)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 61)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.420)
|
||||
@ -1541,7 +1541,7 @@ np.array([['E', 'Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'A', 'L', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.46)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.6e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.6e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 52.98)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 55)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.488)
|
||||
@ -1614,7 +1614,7 @@ np.array([['Q', 'R', 'C', 'G', 'D', 'Q', 'A', 'R', 'G', 'A', 'K', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.25)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 48.31)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 50)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.296)
|
||||
@ -1684,7 +1684,7 @@ np.array([['P', 'N', 'G', 'Q', 'C', 'G', 'P', 'G', 'W', 'G', '-', '-', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.13)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.2e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.2e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 47.19)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 44)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.207)
|
||||
@ -1754,7 +1754,7 @@ np.array([['P', 'N', 'G', 'Q', 'C', 'G', 'P', 'G', 'W', 'G', '-', '-', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.04)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 44.77)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 48)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.444)
|
||||
@ -1821,7 +1821,7 @@ np.array([['R', 'G', 'R', 'C', 'P', 'S', 'G', 'M', 'C', 'C', 'S', 'Q', 'F',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 96.99)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 8.4e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 8.4e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 44.41)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 52)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.425)
|
||||
@ -2669,7 +2669,7 @@ class Align_hhr_2uvo_hhsearch(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.6e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.6e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 249.39)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 2.050)
|
||||
@ -2779,7 +2779,7 @@ np.array([['E', 'R', 'C', 'G', 'E', 'Q', 'G', 'S', 'N', 'M', 'E', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.95)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.8e-33)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.8e-33, places=34)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 204.56)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 49)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.252)
|
||||
@ -2888,7 +2888,7 @@ np.array([['G', 'X', 'G', 'C', 'X', 'G', 'X', 'X', 'M', 'Y', 'C', 'S', 'T',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.84)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-25)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-25, places=26)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 163.39)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 60)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.533)
|
||||
@ -2990,7 +2990,7 @@ np.array([['E', 'R', 'C', 'G', 'E', 'Q', 'G', 'S', 'N', 'M', 'E', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.84)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.5e-25)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.5e-25, places=26)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 157.96)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 52)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.251)
|
||||
@ -3092,7 +3092,7 @@ np.array([['P', 'V', 'C', 'G', 'V', 'R', 'A', 'S', 'G', 'R', 'V', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.82)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.5e-25)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.5e-25, places=26)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 154.69)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 50)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.299)
|
||||
@ -3194,7 +3194,7 @@ np.array([['P', 'V', 'C', 'G', 'V', 'R', 'A', 'S', 'G', 'R', 'V', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.78)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.7e-23)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.7e-23, places=24)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 152.97)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 41)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.180)
|
||||
@ -3296,7 +3296,7 @@ np.array([['G', 'X', 'G', 'C', 'X', 'G', 'X', 'X', 'M', 'Y', 'C', 'S', 'T',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.54)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-18)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-18, places=19)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 113.58)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 48)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.312)
|
||||
@ -3388,7 +3388,7 @@ np.array([['P', 'E', 'C', 'G', 'E', 'R', 'A', 'S', 'G', 'K', 'R', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.54)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-18)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-18, places=19)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 115.94)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 47)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.232)
|
||||
@ -3480,7 +3480,7 @@ np.array([['R', 'C', 'G', 'S', 'Q', 'G', 'G', 'G', 'S', 'T', 'C', 'P', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.41)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.1e-17)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.1e-17, places=18)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 108.07)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 48)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.287)
|
||||
@ -3572,7 +3572,7 @@ np.array([['E', 'R', 'C', 'G', 'S', 'Q', 'G', 'G', 'G', 'S', 'T', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-16, places=17)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 104.25)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 53)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.284)
|
||||
@ -3664,7 +3664,7 @@ np.array([['E', 'C', 'G', 'E', 'R', 'A', 'S', 'G', 'K', 'R', 'C', 'P', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 98.20)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.6e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.6e-09, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 66.41)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 59)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.390)
|
||||
@ -3738,7 +3738,7 @@ np.array([['M', 'E', 'Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'A', 'L', 'C',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 98.12)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.1e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.1e-09, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 64.73)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 68)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.600)
|
||||
@ -3811,7 +3811,7 @@ np.array([['Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'K', 'L', 'C', 'P', 'D',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 98.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 8e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 8e-09, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 63.24)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 49)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.241)
|
||||
@ -3885,7 +3885,7 @@ np.array([['Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'A', 'L', 'C', 'P', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.97)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 61.74)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 59)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.493)
|
||||
@ -3958,7 +3958,7 @@ np.array([['R', 'C', 'G', 'D', 'Q', 'A', 'R', 'G', 'A', 'K', 'C', 'P', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.88)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 62.00)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 49)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.238)
|
||||
@ -4031,7 +4031,7 @@ np.array([['E', 'T', 'C', 'A', '-', 'S', 'R', 'C', 'P', 'R', 'P', 'C', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.83)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.8e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.8e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 58.62)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 44)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.336)
|
||||
@ -4099,7 +4099,7 @@ np.array([['E', 'C', 'V', 'R', 'G', 'R', 'C', 'P', 'S', 'G', 'M', 'C', 'C',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.83)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.9e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.9e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 61.32)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 39)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.187)
|
||||
@ -4172,7 +4172,7 @@ np.array([['T', 'C', 'A', '-', 'S', 'R', 'C', 'P', 'R', 'P', 'C', 'N', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.76)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.7e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.7e-08, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 59.52)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 50)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.302)
|
||||
@ -4246,7 +4246,7 @@ np.array([['E', 'Q', 'C', 'G', 'R', 'Q', 'A', 'G', 'G', 'K', 'L', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.58)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.5e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.5e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 56.59)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 55)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.488)
|
||||
@ -4319,7 +4319,7 @@ np.array([['Q', 'R', 'C', 'G', 'D', 'Q', 'A', 'R', 'G', 'A', 'K', 'C', 'P',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.58)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.6e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.6e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 55.11)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 42)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.250)
|
||||
@ -4386,7 +4386,7 @@ np.array([['C', 'Y', 'R', 'G', 'R', 'C', 'S', 'G', 'G', 'L', 'C', 'C', 'S',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 97.56)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.7e-07)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.7e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 55.43)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 42)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.160)
|
||||
@ -5914,7 +5914,7 @@ class Align_hhr_4p79_hhsearch_server_NOssm(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.94)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-32)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.8e-32, places=33)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 194.63)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.536)
|
||||
@ -6033,7 +6033,7 @@ np.array([['G', 'S', 'E', 'F', 'M', 'S', 'V', 'A', 'V', 'E', 'T', 'F', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.88)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-27)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-27, places=28)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 169.81)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 38)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.775)
|
||||
@ -6150,7 +6150,7 @@ np.array([['M', 'A', 'N', 'S', 'G', 'L', 'Q', 'L', 'L', 'G', 'Y', 'F', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.84)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-25)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-25, places=26)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 176.50)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 37)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.639)
|
||||
@ -6269,7 +6269,7 @@ np.array([['K', 'G', 'M', 'A', 'S', 'M', 'G', 'L', 'Q', 'V', 'M', 'G', 'I',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.82)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.1e-24, places=25)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 168.32)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 15)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.164)
|
||||
@ -6391,7 +6391,7 @@ np.array([['M', 'G', 'L', 'F', 'D', 'R', 'G', 'V', 'Q', 'M', 'L', 'L', 'T',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.81)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-24, places=25)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 159.28)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 17)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.231)
|
||||
@ -6514,7 +6514,7 @@ np.array([['M', 'S', 'P', 'T', 'E', 'A', 'P', 'K', 'V', 'R', 'V', 'T', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.79)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.7e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.7e-24, places=25)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 156.78)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 14)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.065)
|
||||
@ -6633,7 +6633,7 @@ np.array([['N', 'S', 'R', 'A', 'V', 'G', 'V', 'M', 'W', 'G', 'T', 'L', 'T',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.53)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-18)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-18, places=19)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 150.79)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 13)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.177)
|
||||
@ -6850,7 +6850,7 @@ class Align_hhr_4y9h_hhsearch_server_NOssm(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.1e-48)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.1e-48, places=49)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 320.44)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.574)
|
||||
@ -6973,7 +6973,7 @@ np.array([['G', 'R', 'P', 'E', 'W', 'I', 'W', 'L', 'A', 'L', 'G', 'T', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.9e-45)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.9e-45, places=46)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 307.43)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.574)
|
||||
@ -7096,7 +7096,7 @@ np.array([['G', 'R', 'P', 'E', 'W', 'I', 'W', 'L', 'A', 'L', 'G', 'T', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-43)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-43, places=44)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 291.03)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 55)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.956)
|
||||
@ -7219,7 +7219,7 @@ np.array([['G', 'P', 'E', 'S', 'I', 'W', 'L', 'W', 'I', 'G', 'T', 'I', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 291.62)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 57)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.005)
|
||||
@ -7342,7 +7342,7 @@ np.array([['G', 'R', 'P', 'E', 'T', 'L', 'W', 'L', 'G', 'I', 'G', 'T', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.3e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.3e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 289.73)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 55)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.964)
|
||||
@ -7465,7 +7465,7 @@ np.array([['E', 'G', 'E', 'A', 'I', 'W', 'L', 'W', 'L', 'G', 'T', 'A', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 289.87)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 56)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.948)
|
||||
@ -7588,7 +7588,7 @@ np.array([['E', 'G', 'E', 'G', 'I', 'W', 'L', 'A', 'L', 'G', 'T', 'I', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 282.32)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 29)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.533)
|
||||
@ -7711,7 +7711,7 @@ np.array([['V', 'G', 'L', 'T', 'T', 'L', 'F', 'W', 'L', 'G', 'A', 'I', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.6e-42)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.6e-42, places=43)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 282.87)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 29)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.443)
|
||||
@ -7834,7 +7834,7 @@ np.array([['T', 'E', 'T', 'G', 'M', 'I', 'A', 'Q', 'W', 'I', 'V', 'F', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-41)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-41, places=42)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 282.46)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 30)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.544)
|
||||
@ -7952,7 +7952,7 @@ np.array([['L', 'T', 'T', 'L', 'F', 'W', 'L', 'G', 'A', 'I', 'G', 'M', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5e-41)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5e-41, places=42)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 279.16)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 27)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.447)
|
||||
@ -8074,7 +8074,7 @@ np.array([['A', 'Q', 'W', 'V', 'V', 'F', 'A', 'V', 'M', 'A', 'L', 'A', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-40)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.2e-40, places=41)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 279.52)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 28)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.470)
|
||||
@ -8197,7 +8197,7 @@ np.array([['N', 'L', 'E', 'S', 'L', 'L', 'H', 'W', 'I', 'Y', 'V', 'A', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.4e-40)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.4e-40, places=41)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 282.56)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 32)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.598)
|
||||
@ -8322,7 +8322,7 @@ np.array([['S', 'L', 'Y', 'I', 'N', 'I', 'A', 'L', 'A', 'G', 'L', 'S', 'I',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-40)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.2e-40, places=41)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 279.46)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 34)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.606)
|
||||
@ -8445,7 +8445,7 @@ np.array([['S', 'L', 'W', 'V', 'N', 'V', 'A', 'L', 'A', 'G', 'I', 'A', 'I',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.6e-40)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.6e-40, places=41)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 266.44)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 99)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.599)
|
||||
@ -8566,7 +8566,7 @@ np.array([['G', 'R', 'P', 'E', 'W', 'I', 'W', 'L', 'A', 'L', 'G', 'T', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.7e-39)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.7e-39, places=40)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 273.19)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 22)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.327)
|
||||
@ -8698,7 +8698,7 @@ np.array([['Y', 'Q', 'F', 'T', 'S', 'H', 'I', 'L', 'T', 'L', 'G', 'Y', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.3e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.3e-38, places=39)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 275.60)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 16)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.231)
|
||||
@ -8824,7 +8824,7 @@ np.array([['K', 'I', 'G', 'A', 'Q', 'V', 'C', 'Q', 'W', 'I', 'A', 'F', 'S',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.1e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.1e-38, places=39)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 261.06)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 26)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.424)
|
||||
@ -8949,7 +8949,7 @@ np.array([['I', 'S', 'F', 'W', 'L', 'A', 'A', 'A', 'I', 'M', 'L', 'A', 'S',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.9e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 3.9e-38, places=39)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 265.93)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 24)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.298)
|
||||
@ -9074,7 +9074,7 @@ np.array([['L', 'L', 'T', 'M', 'G', 'V', 'G', 'V', 'H', 'F', 'A', 'A', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4e-38, places=38)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 263.73)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 28)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.412)
|
||||
@ -9198,7 +9198,7 @@ np.array([['V', 'L', 'A', 'T', 'Q', 'Y', 'M', 'F', 'W', 'V', 'G', 'F', 'V',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 4.4e-38, places=39)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 263.83)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 27)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.383)
|
||||
@ -9323,7 +9323,7 @@ np.array([['S', 'D', 'T', 'V', 'G', 'V', 'S', 'F', 'W', 'L', 'V', 'T', 'A',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.6e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.6e-38, places=39)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 263.77)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 27)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.402)
|
||||
@ -9448,7 +9448,7 @@ np.array([['L', 'S', 'L', 'T', 'I', 'A', 'G', 'M', 'L', 'A', 'A', 'F', 'V',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7e-38)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 7e-38, places=38)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 264.24)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 22)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.378)
|
||||
@ -9575,7 +9575,7 @@ np.array([['M', 'F', 'S', 'F', 'T', 'V', 'A', 'T', 'M', 'T', 'A', 'S', 'F',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.1e-37)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 6.1e-37, places=38)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 263.90)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 20)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.322)
|
||||
@ -9700,7 +9700,7 @@ np.array([['N', 'I', 'L', 'Q', 'W', 'I', 'T', 'F', 'A', 'L', 'S', 'A', 'L',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-36)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1e-36, places=37)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 249.63)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 23)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.407)
|
||||
@ -9825,7 +9825,7 @@ np.array([['R', 'L', 'F', 'M', 'V', 'A', 'T', 'V', 'G', 'M', 'L', 'A', 'G',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.7e-36)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2.7e-36, places=37)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 255.00)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 21)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.325)
|
||||
@ -9951,7 +9951,7 @@ np.array([['D', 'G', 'I', 'K', 'Y', 'V', 'Q', 'L', '-', '-', '-', 'V', 'M',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.8e-36)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 5.8e-36, places=37)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 247.02)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 24)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.317)
|
||||
@ -10078,7 +10078,7 @@ np.array([['G', 'G', 'F', 'G', 'S', 'Q', 'P', 'F', 'I', 'L', 'A', 'Y', 'I',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 99.28)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.4e-15)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.4e-15, places=16)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 102.00)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 100)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.503)
|
||||
@ -10169,7 +10169,7 @@ np.array([['R', 'P', 'E', 'V', 'A', 'S', 'T', 'F', 'K', 'V', 'L', 'R', 'N',
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 98.44)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 77.33)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 97)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.598)
|
||||
@ -10366,7 +10366,7 @@ class Align_hhr_hhpred_9590198(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.9e-102)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 9.9e-102, places=103)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 792.76)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 53)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.957)
|
||||
@ -13275,7 +13275,7 @@ class Align_hhr_hhsearch_q9bsu1_uniclust_w_ss_pfamA_30(unittest.TestCase):
|
||||
)
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-106)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 2e-106, places=107)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 822.75)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 88)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 1.401)
|
||||
@ -14661,7 +14661,7 @@ class Align_hhr_7rbx_A_hhsearch_trunc(unittest.TestCase):
|
||||
|
||||
alignment = next(alignments)
|
||||
self.assertAlmostEqual(alignment.annotations["Probab"], 100.00)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-115)
|
||||
self.assertAlmostEqual(alignment.annotations["E-value"], 1.8e-115, places=116)
|
||||
self.assertAlmostEqual(alignment.annotations["Score"], 931.2)
|
||||
self.assertAlmostEqual(alignment.annotations["Identities"], 36.0)
|
||||
self.assertAlmostEqual(alignment.annotations["Similarity"], 0.615)
|
||||
|
||||
@ -68,7 +68,7 @@ class TestFastaProtein(unittest.TestCase):
|
||||
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["evalue"], 6.1e-78, places=79)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 275.6)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -163,7 +163,7 @@ np.array([['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'D', 'I', 'R', 'G', 'L',
|
||||
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["evalue"], 3.1e-13, places=14)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 60.7)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -848,7 +848,7 @@ np.array([['P', 'S', 'D', 'E', 'Q', 'L', 'K', 'S', 'G', 'T', 'A', 'S', 'V',
|
||||
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["evalue"], 7.6e-83, places=84)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 291.9)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -943,7 +943,7 @@ np.array([['M', 'P', 'M', 'I', 'L', 'G', 'Y', 'W', 'D', 'I', 'R', 'G', 'L',
|
||||
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["evalue"], 4.4e-14, places=15)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 63.5)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -1640,7 +1640,7 @@ class TestFastaNucleotide(unittest.TestCase):
|
||||
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["evalue"], 3.6e-194, places=195)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 666.0)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -1722,7 +1722,7 @@ pGT875 600 ????????????????????????????????????????????????????????? 65
|
||||
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["evalue"], 1.9e-118, places=119)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 414.4)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -1804,7 +1804,7 @@ pGT875 600 ?????????????????????????????????????????????? 646
|
||||
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["evalue"], 1.2e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 46.4)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -1954,7 +1954,7 @@ np.array([['A', 'G', 'C', 'T', 'C', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'T',
|
||||
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["evalue"], 2.1e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.6)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -2478,7 +2478,7 @@ np.array([['C', 'T', 'G', 'C', 'G', 'G', 'C', 'A', 'C', 'C', 'T', 'G', 'G',
|
||||
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["evalue"], 4.6e-191, places=192)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 655.6)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -2560,7 +2560,7 @@ pGT875 600 ????????????????????????????????????????????????????????? 65
|
||||
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["evalue"], 1.6e-116, places=117)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 408.0)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -2642,7 +2642,7 @@ pGT875 600 ?????????????????????????????????????????????? 646
|
||||
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["evalue"], 1.9e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.7)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -2792,7 +2792,7 @@ np.array([['A', 'G', 'C', 'T', 'C', 'C', 'C', 'C', 'A', 'A', 'G', 'T', 'T',
|
||||
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["evalue"], 3.2e-07, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.0)
|
||||
self.assertEqual(
|
||||
str(alignment),
|
||||
@ -3380,7 +3380,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 199)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3408,7 +3408,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3422,7 +3422,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3436,7 +3436,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 4e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3450,7 +3450,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3464,7 +3464,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-66, places=66)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3478,7 +3478,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3578,7 +3578,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 199)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3606,7 +3606,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3620,7 +3620,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3634,7 +3634,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 4e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3648,7 +3648,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 30.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3662,7 +3662,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-66, places=66)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -3676,7 +3676,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 31.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 100)
|
||||
@ -3731,7 +3731,7 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 199)
|
||||
alignment = next(alignments)
|
||||
self.assertEqual(alignment.query.id, "gi|11464971:4-101")
|
||||
@ -3741,32 +3741,32 @@ class TestBlast(unittest.TestCase):
|
||||
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["evalue"], 2e-67, places=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["evalue"], 3e-09, places=9)
|
||||
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["evalue"], 4e-67, places=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["evalue"], 3e-09, places=9)
|
||||
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["evalue"], 2e-66, places=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["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
|
||||
alignment = next(alignments)
|
||||
self.assertEqual(alignment.query.id, "gi|11464971:4-101")
|
||||
@ -4041,7 +4041,7 @@ gi|114649 60 KRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK 98
|
||||
alignment.query.seq[0:98],
|
||||
"KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 199)
|
||||
self.assertAlmostEqual(alignment.score, 506)
|
||||
self.assertEqual(alignment.shape, (2, 98))
|
||||
@ -4174,7 +4174,7 @@ gi|114649 60 KRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK 98
|
||||
alignment.query.seq[0:98],
|
||||
"KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.score, 515)
|
||||
self.assertEqual(alignment.shape, (2, 98))
|
||||
@ -4242,7 +4242,7 @@ gi|114649 56 QDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA 96
|
||||
alignment.query.seq[2:96],
|
||||
"IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.score, 105)
|
||||
self.assertEqual(alignment.shape, (2, 100))
|
||||
@ -4307,7 +4307,7 @@ gi|114649 60 KRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK 98
|
||||
alignment.query.seq[0:98],
|
||||
"KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-67, places=67)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.score, 515)
|
||||
self.assertEqual(alignment.shape, (2, 98))
|
||||
@ -4375,7 +4375,7 @@ gi|114649 60 KRMF----VLKITTTKQQDHFFQAAFLEERDAWVRDIKKA 96
|
||||
alignment.query.seq[2:96],
|
||||
"IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 45.1)
|
||||
self.assertAlmostEqual(alignment.score, 105)
|
||||
self.assertEqual(alignment.shape, (2, 100))
|
||||
@ -4440,7 +4440,7 @@ gi|114649 60 KRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK 98
|
||||
alignment.query.seq[0:98],
|
||||
"KRIREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKAIK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-66, places=66)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.score, 515)
|
||||
self.assertEqual(alignment.shape, (2, 98))
|
||||
@ -4508,7 +4508,7 @@ gi|114649 56 QDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA 96
|
||||
alignment.query.seq[2:96],
|
||||
"IREGYLVKKGSVFNTWKPMWVVLLEDGIEFYKKKSDNSPKGMIPLKGSTLTSPCQDFGKRMFVLKITTTKQQDHFFQAAFLEERDAWVRDIKKA",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 46.6)
|
||||
self.assertAlmostEqual(alignment.score, 109)
|
||||
self.assertEqual(alignment.shape, (2, 100))
|
||||
@ -4645,7 +4645,7 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
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["evalue"], 1e-63, places=63)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 205)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 100.00)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -4673,7 +4673,7 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
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["evalue"], 1e-62, places=62)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 199)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 95.92)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -4701,7 +4701,7 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
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["evalue"], 2e-62, places=62)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -4729,7 +4729,7 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
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["evalue"], 1e-61, places=61)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -4757,7 +4757,7 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
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["evalue"], 1e-61, places=61)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 202)
|
||||
self.assertAlmostEqual(alignment.annotations["% identity"], 97.96)
|
||||
self.assertEqual(alignment.annotations["alignment length"], 98)
|
||||
@ -4824,28 +4824,28 @@ gi|114649 11 GSVFNTWKPMWVVLL---------EDGIEFYKKKSDNSPKGMIPLKGSTLTS 54
|
||||
self.assertEqual(
|
||||
alignment.target.annotations["ids"], "gi|591387858|ref|XM_007068281.1|"
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-180)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-180, places=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)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-180, places=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)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-173, places=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)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-173, places=173)
|
||||
with self.assertRaises(StopIteration):
|
||||
next(alignments)
|
||||
|
||||
@ -4914,7 +4914,7 @@ gi|296147 60 SLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K 116
|
||||
alignment.query.seq,
|
||||
"WP*TLEGLTPCKGNLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-76)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-76, places=76)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 289)
|
||||
self.assertAlmostEqual(alignment.score, 626)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -5001,7 +5001,7 @@ gi|296147 60 DVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAFAWSQTLQCSWP 116
|
||||
alignment.query.seq,
|
||||
"LLIESPSRDE*PQ*RHPKFQTAGFEE*MERLTVPVGIALPGSSF*HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAFAWSQTLQCSWP",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-73)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-73, places=73)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 278)
|
||||
self.assertAlmostEqual(alignment.score, 602)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -5088,7 +5088,7 @@ gi|296147 60 MSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH 116
|
||||
alignment.query.seq,
|
||||
"F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-72)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-72, places=72)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 274)
|
||||
self.assertAlmostEqual(alignment.score, 593)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -5175,7 +5175,7 @@ gi|296147 60 PFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS 116
|
||||
alignment.query.seq,
|
||||
"GHEHWRV*LHAKAT*SRIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-70)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-70, places=70)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 270)
|
||||
self.assertAlmostEqual(alignment.score, 583)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -5262,7 +5262,7 @@ gi|296147 60 GCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPPVFMA 116
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPPVFMA",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-58)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-58, places=58)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 229)
|
||||
self.assertAlmostEqual(alignment.score, 495)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -5349,7 +5349,7 @@ gi|296147 60 PRSRLSEILDAFIEATHLAMEIQLK 85
|
||||
alignment.query.seq,
|
||||
"TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-53)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-53, places=53)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 197)
|
||||
self.assertAlmostEqual(alignment.score, 425)
|
||||
self.assertEqual(alignment.shape, (2, 85))
|
||||
@ -5426,7 +5426,7 @@ gi|296147 0 MAMNTGGFDSMQRQ 14
|
||||
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["evalue"], 1e-53, places=53)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 36.3)
|
||||
self.assertAlmostEqual(alignment.score, 73)
|
||||
self.assertEqual(alignment.shape, (2, 14))
|
||||
@ -5510,7 +5510,7 @@ gi|296147 60 PRSRLSEILDAFIEATHLAMEIQLK 85
|
||||
alignment.query.seq,
|
||||
"TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-37)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-37, places=37)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 152)
|
||||
self.assertAlmostEqual(alignment.score, 327)
|
||||
self.assertEqual(alignment.shape, (2, 85))
|
||||
@ -5584,7 +5584,7 @@ gi|296147 0 FRIEKKKFNHSPC* 14
|
||||
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["evalue"], 3e-37, places=37)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 26.3)
|
||||
self.assertAlmostEqual(alignment.score, 51)
|
||||
self.assertEqual(alignment.shape, (2, 14))
|
||||
@ -5664,7 +5664,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK 55
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20, places=20)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 68.0)
|
||||
self.assertAlmostEqual(alignment.score, 142)
|
||||
self.assertEqual(alignment.shape, (2, 55))
|
||||
@ -5742,7 +5742,7 @@ gi|296147 0 LFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESN 39
|
||||
self.assertEqual(
|
||||
alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESN"
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-20, places=20)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 52.8)
|
||||
self.assertAlmostEqual(alignment.score, 109)
|
||||
self.assertEqual(alignment.shape, (2, 39))
|
||||
@ -5826,7 +5826,7 @@ gi|296147 60 *RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K 103
|
||||
alignment.query.seq,
|
||||
"NLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 9e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 9e-08, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 61.1)
|
||||
self.assertAlmostEqual(alignment.score, 127)
|
||||
self.assertEqual(alignment.shape, (2, 103))
|
||||
@ -5994,7 +5994,7 @@ gi|296147 60 PRSRLSEILDAFIEATHLAMEIQLK 85
|
||||
alignment.query.seq,
|
||||
"TIRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-32)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-32, places=32)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 143)
|
||||
self.assertAlmostEqual(alignment.score, 306)
|
||||
self.assertEqual(alignment.shape, (2, 85))
|
||||
@ -6074,7 +6074,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANT 54
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANT",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16, places=16)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 62.5)
|
||||
self.assertAlmostEqual(alignment.score, 130)
|
||||
self.assertEqual(alignment.shape, (2, 54))
|
||||
@ -6148,7 +6148,7 @@ gi|296147 0 LFNISMDLSLAWRMVEFLLFDSEDKERNSASSC 33
|
||||
self.assertEqual(alignment.target.annotations["end"], 38)
|
||||
self.assertEqual(alignment.target.seq, "VFKISIDLSLACLIEVFLLLDSEDNECNSRSNC")
|
||||
self.assertEqual(alignment.query.seq, "LFNISMDLSLAWRMVEFLLFDSEDKERNSASSC")
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-16, places=16)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 44.6)
|
||||
self.assertAlmostEqual(alignment.score, 91)
|
||||
self.assertEqual(alignment.shape, (2, 33))
|
||||
@ -6316,7 +6316,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-32)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-32, places=32)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 141)
|
||||
self.assertAlmostEqual(alignment.score, 303)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -6480,7 +6480,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-32)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-32, places=32)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 141)
|
||||
self.assertAlmostEqual(alignment.score, 302)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -6559,7 +6559,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLD 49
|
||||
self.assertEqual(
|
||||
alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLD"
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 51.0)
|
||||
self.assertAlmostEqual(alignment.score, 105)
|
||||
self.assertEqual(alignment.shape, (2, 49))
|
||||
@ -6637,7 +6637,7 @@ gi|296147 0 TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPP 42
|
||||
self.assertEqual(
|
||||
alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCLCMESNPP"
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 41.8)
|
||||
self.assertAlmostEqual(alignment.score, 85)
|
||||
self.assertEqual(alignment.shape, (2, 42))
|
||||
@ -6805,7 +6805,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-31)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-31, places=31)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 139)
|
||||
self.assertAlmostEqual(alignment.score, 299)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -6889,7 +6889,7 @@ gi|296147 60 SLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K 116
|
||||
alignment.query.seq,
|
||||
"WP*TLEGLTPCKGNLKQNCVLYLPNRKEEIQPFAMLVINPLRY*KEYIVLRS*KDIRISHSLSCWLANQGMLK*RPWQCNAYRDCQPFHLFLEAGCLKFWMPSLRLLISRWRFN*K",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-14)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-14, places=14)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 81.3)
|
||||
self.assertAlmostEqual(alignment.score, 171)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -6973,7 +6973,7 @@ gi|296147 60 MSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH 116
|
||||
alignment.query.seq,
|
||||
"F*LNLHREMSSLNEGIQNFRQPASRNRWNG*QSL*ALHCQGRHFSIP*LASQHERECEIRMSF*LLKTMYSFQYLNGFITSMANG*ISSFRFGR*RTQFCFKLPLHGVKPSSVHGH",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 72.1)
|
||||
self.assertAlmostEqual(alignment.score, 151)
|
||||
self.assertEqual(alignment.shape, (2, 116))
|
||||
@ -7051,7 +7051,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAF 47
|
||||
self.assertEqual(
|
||||
alignment.query.seq, "TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAF"
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 47.3)
|
||||
self.assertAlmostEqual(alignment.score, 97)
|
||||
self.assertEqual(alignment.shape, (2, 47))
|
||||
@ -7135,7 +7135,7 @@ gi|296147 60
|
||||
alignment.query.seq,
|
||||
"HSLIGKPTRKGVRNPDVFLAPQNYVLFSISQWIYH*HGEWLNFFFSIRKIKNAILLQVAF",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 40.5)
|
||||
self.assertAlmostEqual(alignment.score, 82)
|
||||
self.assertEqual(alignment.shape, (2, 60))
|
||||
@ -7219,7 +7219,7 @@ gi|296147 60 *NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS 105
|
||||
alignment.query.seq,
|
||||
"KAT*SRIAFFIFRIEKKKFNHSPC***IH*DIEKST*F*GARKTSGFRTPFRVGLPIKEC*NDDPGNAMPTGTVNRSIYSSKPAV*NFGCLH*GYSSRDGDSIKS",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-08, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 62.5)
|
||||
self.assertAlmostEqual(alignment.score, 130)
|
||||
self.assertEqual(alignment.shape, (2, 105))
|
||||
@ -7377,7 +7377,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28, places=28)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 129)
|
||||
self.assertAlmostEqual(alignment.score, 276)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -7461,7 +7461,7 @@ gi|296147 60 GCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL 105
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTKGSAKSGCLSSSSKLCTLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 67.5)
|
||||
self.assertAlmostEqual(alignment.score, 141)
|
||||
self.assertEqual(alignment.shape, (2, 105))
|
||||
@ -7545,7 +7545,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-28, places=28)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 129)
|
||||
self.assertAlmostEqual(alignment.score, 276)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -7797,7 +7797,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-28)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-28, places=28)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 128)
|
||||
self.assertAlmostEqual(alignment.score, 274)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -8033,7 +8033,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27, places=27)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 127)
|
||||
self.assertAlmostEqual(alignment.score, 271)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -8355,7 +8355,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-27, places=27)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 127)
|
||||
self.assertAlmostEqual(alignment.score, 271)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -8435,7 +8435,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK 55
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQANTK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 52.4)
|
||||
self.assertAlmostEqual(alignment.score, 108)
|
||||
self.assertEqual(alignment.shape, (2, 55))
|
||||
@ -8509,7 +8509,7 @@ gi|296147 0 TLFNISMDLSLAWRMVEFLLFDSED 25
|
||||
self.assertEqual(alignment.target.annotations["end"], 62)
|
||||
self.assertEqual(alignment.target.seq, "TILKI*SDLSDACLTSEFLLLDSED")
|
||||
self.assertEqual(alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSED")
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-08, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 27.2)
|
||||
self.assertAlmostEqual(alignment.score, 53)
|
||||
self.assertEqual(alignment.shape, (2, 25))
|
||||
@ -8841,7 +8841,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-26)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-26, places=26)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 123)
|
||||
self.assertAlmostEqual(alignment.score, 263)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -9245,7 +9245,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-24)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-24, places=24)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 115)
|
||||
self.assertAlmostEqual(alignment.score, 246)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -9325,7 +9325,7 @@ gi|296147 0 TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQ 51
|
||||
alignment.query.seq,
|
||||
"TFN*ISIAR*VASMKASKISDSRLRGIDGTVDSPCRHCIARVVILAFLDWQ",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 48.3)
|
||||
self.assertAlmostEqual(alignment.score, 99)
|
||||
self.assertEqual(alignment.shape, (2, 51))
|
||||
@ -9401,7 +9401,7 @@ gi|296147 0 TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL 35
|
||||
alignment.target.seq, "TVLRISIDLSLACLMAELLFFASEDKSCNSEFNCL"
|
||||
)
|
||||
self.assertEqual(alignment.query.seq, "TLFNISMDLSLAWRMVEFLLFDSEDKERNSASSCL")
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 43.7)
|
||||
self.assertAlmostEqual(alignment.score, 89)
|
||||
self.assertEqual(alignment.shape, (2, 35))
|
||||
@ -9485,7 +9485,7 @@ gi|296147 60 RSRLSEILDAFIEATHLAMEIQLK 84
|
||||
alignment.query.seq,
|
||||
"IRHASDKSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-20)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-20, places=20)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 103)
|
||||
self.assertAlmostEqual(alignment.score, 219)
|
||||
self.assertEqual(alignment.shape, (2, 84))
|
||||
@ -9569,7 +9569,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-13)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-13, places=13)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 79.9)
|
||||
self.assertAlmostEqual(alignment.score, 168)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -9653,7 +9653,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-13)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-13, places=13)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 78.5)
|
||||
self.assertAlmostEqual(alignment.score, 165)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -9737,7 +9737,7 @@ gi|296147 60 MEIQLK 66
|
||||
alignment.query.seq,
|
||||
"EELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-12)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-12, places=12)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 77.1)
|
||||
self.assertAlmostEqual(alignment.score, 162)
|
||||
self.assertEqual(alignment.shape, (2, 66))
|
||||
@ -9821,7 +9821,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-12)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-12, places=12)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 76.7)
|
||||
self.assertAlmostEqual(alignment.score, 161)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -9905,7 +9905,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-12)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-12, places=12)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 75.3)
|
||||
self.assertAlmostEqual(alignment.score, 158)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -9989,7 +9989,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 73.5)
|
||||
self.assertAlmostEqual(alignment.score, 154)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -10073,7 +10073,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 72.5)
|
||||
self.assertAlmostEqual(alignment.score, 152)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -10157,7 +10157,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 72.5)
|
||||
self.assertAlmostEqual(alignment.score, 152)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -10241,7 +10241,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 6e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 71.6)
|
||||
self.assertAlmostEqual(alignment.score, 150)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10325,7 +10325,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
|
||||
self.assertAlmostEqual(alignment.score, 149)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10409,7 +10409,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
|
||||
self.assertAlmostEqual(alignment.score, 149)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10493,7 +10493,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 8e-11, places=11)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 71.2)
|
||||
self.assertAlmostEqual(alignment.score, 149)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10577,7 +10577,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 70.3)
|
||||
self.assertAlmostEqual(alignment.score, 147)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10661,7 +10661,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 69.8)
|
||||
self.assertAlmostEqual(alignment.score, 146)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10745,7 +10745,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 69.8)
|
||||
self.assertAlmostEqual(alignment.score, 146)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10829,7 +10829,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 69.3)
|
||||
self.assertAlmostEqual(alignment.score, 145)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -10913,7 +10913,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 3e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 69.3)
|
||||
self.assertAlmostEqual(alignment.score, 145)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -10997,7 +10997,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
|
||||
self.assertAlmostEqual(alignment.score, 144)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11081,7 +11081,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
|
||||
self.assertAlmostEqual(alignment.score, 144)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11165,7 +11165,7 @@ gi|296147 60 ILDAFIEATHLAMEIQLK 78
|
||||
alignment.query.seq,
|
||||
"KSIEILKRVHSFEELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 4e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 68.9)
|
||||
self.assertAlmostEqual(alignment.score, 144)
|
||||
self.assertEqual(alignment.shape, (2, 78))
|
||||
@ -11249,7 +11249,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-10)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 7e-10, places=10)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 68.0)
|
||||
self.assertAlmostEqual(alignment.score, 142)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11333,7 +11333,7 @@ gi|296147 60 MEIQLK 66
|
||||
alignment.query.seq,
|
||||
"EELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 1e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 67.0)
|
||||
self.assertAlmostEqual(alignment.score, 140)
|
||||
self.assertEqual(alignment.shape, (2, 66))
|
||||
@ -11417,7 +11417,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 66.6)
|
||||
self.assertAlmostEqual(alignment.score, 139)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11501,7 +11501,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 66.6)
|
||||
self.assertAlmostEqual(alignment.score, 139)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11585,7 +11585,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 5e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 65.2)
|
||||
self.assertAlmostEqual(alignment.score, 136)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11669,7 +11669,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 9e-09)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 9e-09, places=9)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 64.3)
|
||||
self.assertAlmostEqual(alignment.score, 134)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
@ -11753,7 +11753,7 @@ gi|296147 60 EIQLK 65
|
||||
alignment.query.seq,
|
||||
"ELERHPDFALPFVLACQSRNAKMTTLAMQCLQGLSTVPSIPRSRLSEILDAFIEATHLAMEIQLK",
|
||||
)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-08)
|
||||
self.assertAlmostEqual(alignment.annotations["evalue"], 2e-08, places=8)
|
||||
self.assertAlmostEqual(alignment.annotations["bit score"], 63.4)
|
||||
self.assertAlmostEqual(alignment.score, 132)
|
||||
self.assertEqual(alignment.shape, (2, 65))
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -530,7 +530,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.66928e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.66928e-10, places=15)
|
||||
|
||||
alignment = alignments[24]
|
||||
self.assertEqual(
|
||||
@ -538,7 +538,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 77)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.18014e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.18014e-10, places=15)
|
||||
|
||||
alignment = alignments[25]
|
||||
self.assertEqual(
|
||||
@ -546,7 +546,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 74)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.71876e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.71876e-10, places=15)
|
||||
|
||||
alignment = alignments[26]
|
||||
self.assertEqual(
|
||||
@ -554,7 +554,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 88)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.71876e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.71876e-10, places=15)
|
||||
|
||||
alignment = alignments[27]
|
||||
self.assertEqual(
|
||||
@ -562,7 +562,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 79)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.85685e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.85685e-10, places=15)
|
||||
|
||||
alignment = alignments[28]
|
||||
self.assertEqual(
|
||||
@ -570,7 +570,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 79)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.34325e-10)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.34325e-10, places=15)
|
||||
|
||||
alignment = alignments[29]
|
||||
self.assertEqual(
|
||||
@ -578,7 +578,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 81)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.08199e-09)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.08199e-09, places=14)
|
||||
|
||||
alignment = alignments[30]
|
||||
self.assertEqual(
|
||||
@ -586,7 +586,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 83)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.41313e-09)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.41313e-09, places=14)
|
||||
|
||||
alignment = alignments[31]
|
||||
self.assertEqual(
|
||||
@ -594,7 +594,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 82)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.5624e-08)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.5624e-08, places=12)
|
||||
|
||||
alignment = alignments[32]
|
||||
self.assertEqual(
|
||||
@ -602,7 +602,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 90)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.04055e-08)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.04055e-08, places=13)
|
||||
|
||||
alignment = alignments[33]
|
||||
self.assertEqual(
|
||||
@ -610,7 +610,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 70)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.48066e-08)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.48066e-08, places=13)
|
||||
|
||||
alignment = alignments[34]
|
||||
self.assertEqual(
|
||||
@ -618,7 +618,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 90)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.9371e-08)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.9371e-08, places=12)
|
||||
|
||||
alignment = alignments[35]
|
||||
self.assertEqual(
|
||||
@ -626,7 +626,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 67)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.32265e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.32265e-07, places=12)
|
||||
|
||||
alignment = alignments[36]
|
||||
self.assertEqual(
|
||||
@ -634,7 +634,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.72743e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.72743e-07, places=12)
|
||||
|
||||
alignment = alignments[37]
|
||||
self.assertEqual(
|
||||
@ -642,19 +642,19 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 73)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.2561e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.2561e-07, places=11)
|
||||
|
||||
alignment = alignments[38]
|
||||
self.assertEqual(alignment.title[:50], "gi|455172|gb|AAA24073.1| ORF; putative")
|
||||
self.assertEqual(alignment.length, 67)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.94655e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.94655e-07, places=12)
|
||||
|
||||
alignment = alignments[39]
|
||||
self.assertEqual(alignment.title[:50], "gi|1224007|gb|AAA92108.1| ORF4")
|
||||
self.assertEqual(alignment.length, 192)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.84832e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.84832e-07, places=12)
|
||||
|
||||
alignment = alignments[40]
|
||||
self.assertEqual(
|
||||
@ -662,7 +662,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 95)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.56423e-07)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.56423e-07, places=12)
|
||||
|
||||
alignment = alignments[41]
|
||||
self.assertEqual(
|
||||
@ -670,7 +670,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 73)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.11969e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.11969e-06, places=11)
|
||||
|
||||
alignment = alignments[42]
|
||||
self.assertEqual(
|
||||
@ -678,7 +678,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 84)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.46236e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.46236e-06, places=11)
|
||||
|
||||
alignment = alignments[43]
|
||||
self.assertEqual(
|
||||
@ -686,7 +686,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 75)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.9099e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.9099e-06, places=10)
|
||||
|
||||
alignment = alignments[44]
|
||||
self.assertEqual(
|
||||
@ -694,7 +694,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 109)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.49441e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.49441e-06, places=11)
|
||||
|
||||
alignment = alignments[45]
|
||||
self.assertEqual(
|
||||
@ -702,7 +702,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 77)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06, places=11)
|
||||
|
||||
alignment = alignments[46]
|
||||
self.assertEqual(
|
||||
@ -710,7 +710,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06, places=11)
|
||||
|
||||
alignment = alignments[47]
|
||||
self.assertEqual(
|
||||
@ -718,7 +718,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 85)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06, places=11)
|
||||
|
||||
alignment = alignments[48]
|
||||
self.assertEqual(
|
||||
@ -726,7 +726,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 65)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.25779e-06, places=11)
|
||||
|
||||
alignment = alignments[49]
|
||||
self.assertEqual(
|
||||
@ -734,7 +734,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06, places=11)
|
||||
|
||||
alignment = alignments[50]
|
||||
self.assertEqual(
|
||||
@ -742,7 +742,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 75)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06, places=11)
|
||||
|
||||
alignment = alignments[51]
|
||||
self.assertEqual(
|
||||
@ -750,7 +750,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.25481e-06, places=11)
|
||||
|
||||
alignment = alignments[52]
|
||||
self.assertEqual(
|
||||
@ -758,7 +758,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 75)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06, places=11)
|
||||
|
||||
alignment = alignments[53]
|
||||
self.assertEqual(
|
||||
@ -766,7 +766,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 85)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06, places=11)
|
||||
|
||||
alignment = alignments[54]
|
||||
self.assertEqual(
|
||||
@ -774,7 +774,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 5.55696e-06, places=11)
|
||||
|
||||
alignment = alignments[55]
|
||||
self.assertEqual(
|
||||
@ -782,7 +782,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 89)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 7.25761e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 7.25761e-06, places=11)
|
||||
|
||||
alignment = alignments[56]
|
||||
self.assertEqual(
|
||||
@ -790,7 +790,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 73)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 9.47873e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 9.47873e-06, places=11)
|
||||
|
||||
alignment = alignments[57]
|
||||
self.assertEqual(
|
||||
@ -798,7 +798,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 77)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 9.47873e-06)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 9.47873e-06, places=11)
|
||||
|
||||
alignment = alignments[58]
|
||||
self.assertEqual(
|
||||
@ -806,7 +806,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 67)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.61683e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.61683e-05, places=10)
|
||||
|
||||
alignment = alignments[59]
|
||||
self.assertEqual(
|
||||
@ -814,7 +814,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 77)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.61683e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 1.61683e-05, places=10)
|
||||
|
||||
alignment = alignments[60]
|
||||
self.assertEqual(
|
||||
@ -822,7 +822,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 79)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05, places=10)
|
||||
|
||||
alignment = alignments[61]
|
||||
self.assertEqual(
|
||||
@ -830,7 +830,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 92)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05, places=10)
|
||||
|
||||
alignment = alignments[62]
|
||||
self.assertEqual(
|
||||
@ -838,7 +838,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 57)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 2.75789e-05, places=10)
|
||||
|
||||
alignment = alignments[63]
|
||||
self.assertEqual(
|
||||
@ -846,7 +846,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 75)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.60191e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.60191e-05, places=10)
|
||||
|
||||
alignment = alignments[64]
|
||||
self.assertEqual(
|
||||
@ -854,7 +854,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 68)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.60191e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 3.60191e-05, places=10)
|
||||
|
||||
alignment = alignments[65]
|
||||
self.assertEqual(
|
||||
@ -862,7 +862,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 83)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.70425e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.70425e-05, places=10)
|
||||
|
||||
alignment = alignments[66]
|
||||
self.assertEqual(
|
||||
@ -870,7 +870,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 90)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.70425e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 4.70425e-05, places=10)
|
||||
|
||||
alignment = alignments[67]
|
||||
self.assertEqual(
|
||||
@ -878,7 +878,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 78)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.14393e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 6.14393e-05, places=10)
|
||||
|
||||
alignment = alignments[68]
|
||||
self.assertEqual(
|
||||
@ -886,7 +886,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 75)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05, places=10)
|
||||
|
||||
alignment = alignments[69]
|
||||
self.assertEqual(
|
||||
@ -894,7 +894,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 70)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05, places=10)
|
||||
|
||||
alignment = alignments[70]
|
||||
self.assertEqual(
|
||||
@ -902,7 +902,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 80)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05, places=10)
|
||||
|
||||
alignment = alignments[71]
|
||||
self.assertEqual(
|
||||
@ -910,7 +910,7 @@ class TestNCBIXML(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(alignment.length, 76)
|
||||
self.assertEqual(len(alignment.hsps), 1)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05)
|
||||
self.assertAlmostEqual(alignment.hsps[0].expect, 8.02423e-05, places=10)
|
||||
|
||||
alignment = alignments[72]
|
||||
self.assertEqual(
|
||||
|
||||
@ -31,7 +31,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual("SEED", hit.id)
|
||||
self.assertEqual("<unknown description>", hit.description)
|
||||
self.assertAlmostEqual(146.1, hit.bitscore)
|
||||
self.assertAlmostEqual(6.3e-40, hit.evalue)
|
||||
self.assertAlmostEqual(6.3e-40, hit.evalue, places=41)
|
||||
self.assertEqual(2, hit.domain_obs_num)
|
||||
self.assertEqual(2, len(hit))
|
||||
|
||||
@ -44,7 +44,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual(103, hsp.query_end)
|
||||
self.assertEqual("..", hsp.query_endtype)
|
||||
self.assertAlmostEqual(71.2, hsp.bitscore)
|
||||
self.assertAlmostEqual(2.2e-17, hsp.evalue)
|
||||
self.assertAlmostEqual(2.2e-17, hsp.evalue, places=18)
|
||||
self.assertEqual(
|
||||
"lfVgNLppdvteedLkdlFskfGpivsikivrDiiekpketgkskGfaFVeFeseedAekAlealnG.kelggrklrv",
|
||||
hsp.hit.seq,
|
||||
@ -67,7 +67,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual(194, hsp.query_end)
|
||||
self.assertEqual("..", hsp.query_endtype)
|
||||
self.assertAlmostEqual(75.5, hsp.bitscore)
|
||||
self.assertAlmostEqual(1.1e-18, hsp.evalue)
|
||||
self.assertAlmostEqual(1.1e-18, hsp.evalue, places=19)
|
||||
self.assertEqual(
|
||||
"lfVgNLppdvteedLkdlFskfGpivsikivrDiiekpketgkskGfaFVeFeseedAekAlealnGkelggrklrv",
|
||||
hsp.hit.seq,
|
||||
@ -152,7 +152,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual("Glu_synthase", hit.id)
|
||||
self.assertEqual("Conserved region in glutamate synthas", hit.description)
|
||||
self.assertAlmostEqual(858.6, hit.bitscore)
|
||||
self.assertAlmostEqual(3.6e-255, hit.evalue)
|
||||
self.assertAlmostEqual(3.6e-255, hit.evalue, places=256)
|
||||
self.assertEqual(2, hit.domain_obs_num)
|
||||
self.assertEqual(2, len(hit))
|
||||
|
||||
@ -181,7 +181,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual(1216, hsp.query_end)
|
||||
self.assertEqual("..", hsp.query_endtype)
|
||||
self.assertAlmostEqual(857.3, hsp.bitscore)
|
||||
self.assertAlmostEqual(9e-255, hsp.evalue)
|
||||
self.assertAlmostEqual(9e-255, hsp.evalue, places=255)
|
||||
|
||||
def test_hmmpfam_23_no_match(self):
|
||||
"""Test parsing hmmpfam 2.3 file (text_23_hmmpfam_002.out)."""
|
||||
@ -284,7 +284,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
self.assertEqual("Xpo1", hit.id)
|
||||
self.assertEqual("Exportin 1-like protein", hit.description)
|
||||
self.assertAlmostEqual(170.1, hit.bitscore)
|
||||
self.assertAlmostEqual(5.1e-48, hit.evalue)
|
||||
self.assertAlmostEqual(5.1e-48, hit.evalue, places=49)
|
||||
self.assertEqual(1, hit.domain_obs_num)
|
||||
self.assertEqual(1, len(hit))
|
||||
|
||||
@ -292,7 +292,7 @@ class HmmpfamTests(unittest.TestCase):
|
||||
hsp = hit[0]
|
||||
self.assertEqual(1, hsp.domain_index)
|
||||
self.assertAlmostEqual(170.1, hsp.bitscore)
|
||||
self.assertAlmostEqual(5.1e-148, hsp.evalue)
|
||||
self.assertAlmostEqual(5.1e-48, hsp.evalue, places=49)
|
||||
self.assertEqual(108, hsp.query_start)
|
||||
self.assertEqual(271, hsp.query_end)
|
||||
self.assertEqual("..", hsp.query_endtype)
|
||||
@ -372,7 +372,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
self.assertEqual("PAB2_ARATH", hit.id)
|
||||
self.assertEqual("P42731 POLYADENYLATE-BINDING PROTEIN 2 (PO", hit.description)
|
||||
self.assertAlmostEqual(393.8, hit.bitscore)
|
||||
self.assertAlmostEqual(6.1e-114, hit.evalue)
|
||||
self.assertAlmostEqual(6.1e-114, hit.evalue, places=145)
|
||||
self.assertEqual(4, hit.domain_obs_num)
|
||||
self.assertEqual(4, len(hit))
|
||||
|
||||
@ -386,7 +386,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(3, hsp.domain_index)
|
||||
self.assertAlmostEqual(109.1, hsp.bitscore)
|
||||
self.assertAlmostEqual(3e-28, hsp.evalue)
|
||||
self.assertAlmostEqual(3e-28, hsp.evalue, places=28)
|
||||
self.assertEqual(0, hsp.query_start)
|
||||
self.assertEqual(77, hsp.query_end)
|
||||
self.assertEqual("[]", hsp.query_endtype)
|
||||
@ -404,7 +404,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(1, hsp.domain_index)
|
||||
self.assertAlmostEqual(92.1, hsp.bitscore)
|
||||
self.assertAlmostEqual(3.9e-23, hsp.evalue)
|
||||
self.assertAlmostEqual(3.9e-23, hsp.evalue, places=24)
|
||||
self.assertEqual(0, hsp.query_start)
|
||||
self.assertEqual(77, hsp.query_end)
|
||||
self.assertEqual("[]", hsp.query_endtype)
|
||||
@ -456,7 +456,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
self.assertEqual("CATL_RAT", hit.id)
|
||||
self.assertEqual("<unknown description>", hit.description)
|
||||
self.assertAlmostEqual(449.4, hit.bitscore)
|
||||
self.assertAlmostEqual(2e-135, hit.evalue)
|
||||
self.assertAlmostEqual(2e-135, hit.evalue, places=135)
|
||||
self.assertEqual(1, hit.domain_obs_num)
|
||||
self.assertEqual(1, len(hit))
|
||||
|
||||
@ -468,7 +468,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
self.assertEqual("<unknown description>", hit.description)
|
||||
self.assertEqual(1, hsp.domain_index)
|
||||
self.assertAlmostEqual(449.4, hsp.bitscore)
|
||||
self.assertAlmostEqual(2e-135, hsp.evalue)
|
||||
self.assertAlmostEqual(2e-135, hsp.evalue, places=135)
|
||||
self.assertEqual(0, hsp.query_start)
|
||||
self.assertEqual(337, hsp.query_end)
|
||||
self.assertEqual("[]", hsp.query_endtype)
|
||||
@ -497,7 +497,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
self.assertEqual("PAPA_CARPA", hit.id)
|
||||
self.assertEqual("<unknown description>", hit.description)
|
||||
self.assertAlmostEqual(337.7, hit.bitscore)
|
||||
self.assertAlmostEqual(9e-102, hit.evalue)
|
||||
self.assertAlmostEqual(9e-102, hit.evalue, places=102)
|
||||
self.assertEqual(1, hit.domain_obs_num)
|
||||
self.assertEqual(1, len(hit))
|
||||
|
||||
@ -509,7 +509,7 @@ class HmmsearchTests(unittest.TestCase):
|
||||
self.assertEqual("<unknown description>", hit.description)
|
||||
self.assertEqual(1, hsp.domain_index)
|
||||
self.assertAlmostEqual(337.7, hsp.bitscore)
|
||||
self.assertAlmostEqual(9e-102, hsp.evalue)
|
||||
self.assertAlmostEqual(9e-102, hsp.evalue, places=102)
|
||||
self.assertEqual(0, hsp.query_start)
|
||||
self.assertEqual(337, hsp.query_end)
|
||||
self.assertEqual("[]", hsp.query_endtype)
|
||||
|
||||
@ -3135,13 +3135,13 @@ class TestMEME(unittest.TestCase):
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 7)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 1.21e-08)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 1.87e-08)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.62e-08)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.05e-07)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 1.69e-07)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 5.62e-07)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 1.08e-06)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 1.21e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 1.87e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.62e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.05e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 1.69e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 5.62e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 1.08e-06, places=8)
|
||||
self.assertEqual(motif.instances[0].sequence_name, "INO1")
|
||||
self.assertEqual(motif.instances[1].sequence_name, "FAS1")
|
||||
self.assertEqual(motif.instances[2].sequence_name, "ACC1")
|
||||
@ -3185,13 +3185,13 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.instances[5], "GTAGCATGTGAAA")
|
||||
self.assertEqual(motif.instances[6], "AGTGCATGTGGAA")
|
||||
self.assertEqual(len(motif.alignment.sequences), 7)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 1.21e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 1.87e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.62e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.05e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 1.69e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 5.62e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 1.08e-06)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 1.21e-08, places=10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 1.87e-08, places=10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.62e-08, places=10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.05e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 1.69e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 5.62e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 1.08e-06, places=8)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_name, "INO1")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_name, "FAS1")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_name, "ACC1")
|
||||
@ -3268,13 +3268,13 @@ class TestMEME(unittest.TestCase):
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 7)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 7.2e-10)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 2.56e-08)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.59e-07)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.05e-07)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 3.85e-07)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 5.11e-07)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 8.01e-07)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 7.2e-10, places=11)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 2.56e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.59e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.05e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 3.85e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 5.11e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 8.01e-07, places=9)
|
||||
self.assertEqual(motif.instances[0].sequence_id, "sequence_1")
|
||||
self.assertEqual(motif.instances[1].sequence_id, "sequence_6")
|
||||
self.assertEqual(motif.instances[2].sequence_id, "sequence_4")
|
||||
@ -3311,13 +3311,13 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.instances[5], "TTGACAACGGCTGGG")
|
||||
self.assertEqual(motif.instances[6], "TTCACGCTTGCTACG")
|
||||
self.assertEqual(len(motif.alignment.sequences), 7)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 7.2e-10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 2.56e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.59e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.05e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 3.85e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 5.11e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 8.01e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 7.2e-10, places=11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 2.56e-08, places=10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.59e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.05e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 3.85e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 5.11e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 8.01e-07, places=9)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_id, "sequence_1")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_id, "sequence_6")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_id, "sequence_4")
|
||||
@ -3433,44 +3433,44 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.alt_id, "MEME-1")
|
||||
self.assertEqual(record["GKVALVTGAASGJGKATAKAL"], motif)
|
||||
self.assertEqual(motif.num_occurrences, 33)
|
||||
self.assertAlmostEqual(motif.evalue, 3.6e-165)
|
||||
self.assertAlmostEqual(motif.evalue, 4.0e-129, places=130)
|
||||
self.assertEqual(motif.alphabet, "ACDEFGHIKLMNPQRSTVWY")
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 33)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 8.78e-18)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 1.41e-17)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.42e-16)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.75e-16)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 3.55e-16)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 3.55e-16)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 1.74e-15)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 3.87e-15)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 4.84e-15)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 1.04e-14)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 1.58e-14)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 1.76e-14)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 2.16e-14)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 2.94e-14)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 3.25e-14)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 3.98e-14)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 4.39e-14)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 4.39e-14)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 4.85e-14)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 6.52e-14)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 1.41e-13)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 1.55e-13)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 3.07e-12)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 5.43e-12)
|
||||
self.assertAlmostEqual(motif.instances[24].pvalue, 6.91e-12)
|
||||
self.assertAlmostEqual(motif.instances[25].pvalue, 8.76e-12)
|
||||
self.assertAlmostEqual(motif.instances[26].pvalue, 9.48e-12)
|
||||
self.assertAlmostEqual(motif.instances[27].pvalue, 1.2e-11)
|
||||
self.assertAlmostEqual(motif.instances[28].pvalue, 1.19e-09)
|
||||
self.assertAlmostEqual(motif.instances[29].pvalue, 1.54e-09)
|
||||
self.assertAlmostEqual(motif.instances[30].pvalue, 1.99e-09)
|
||||
self.assertAlmostEqual(motif.instances[31].pvalue, 1.42e-06)
|
||||
self.assertAlmostEqual(motif.instances[32].pvalue, 3.43e-06)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 8.78e-18, places=20)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 1.41e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.42e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.75e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 3.55e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 3.55e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 1.74e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 3.87e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 4.84e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 1.04e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 1.58e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 1.76e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 2.16e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 2.94e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 3.25e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 3.98e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 4.39e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 4.39e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 4.85e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 6.52e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 1.41e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 1.55e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 3.07e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 5.43e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[24].pvalue, 6.91e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[25].pvalue, 8.76e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[26].pvalue, 9.48e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[27].pvalue, 1.2e-11, places=12)
|
||||
self.assertAlmostEqual(motif.instances[28].pvalue, 1.19e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[29].pvalue, 1.54e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[30].pvalue, 1.99e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[31].pvalue, 1.42e-06, places=8)
|
||||
self.assertAlmostEqual(motif.instances[32].pvalue, 3.43e-06, places=8)
|
||||
self.assertEqual(motif.instances[0].sequence_name, "BUDC_KLETE")
|
||||
self.assertEqual(motif.instances[1].sequence_name, "YINL_LISMO")
|
||||
self.assertEqual(motif.instances[2].sequence_name, "DHII_HUMAN")
|
||||
@ -3670,39 +3670,79 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.instances[31], "VDVLINNAGVSGLWCALGDVD")
|
||||
self.assertEqual(motif.instances[32], "IIDTNVTGAAATLSAVLPQMV")
|
||||
self.assertEqual(len(motif.alignment.sequences), 33)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 8.78e-18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 1.41e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.42e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.75e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 3.55e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 3.55e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 1.74e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 3.87e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 4.84e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 1.04e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[10].pvalue, 1.58e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[11].pvalue, 1.76e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[12].pvalue, 2.16e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[13].pvalue, 2.94e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[14].pvalue, 3.25e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[15].pvalue, 3.98e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 4.39e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[17].pvalue, 4.39e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[18].pvalue, 4.85e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[19].pvalue, 6.52e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[20].pvalue, 1.41e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[21].pvalue, 1.55e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[22].pvalue, 3.07e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[23].pvalue, 5.43e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[24].pvalue, 6.91e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[25].pvalue, 8.76e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[26].pvalue, 9.48e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[27].pvalue, 1.2e-11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[28].pvalue, 1.19e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[29].pvalue, 1.54e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[30].pvalue, 1.99e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[31].pvalue, 1.42e-06)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[32].pvalue, 3.43e-06)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 8.78e-18, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 1.41e-17, places=19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.42e-16, places=18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.75e-16, places=18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 3.55e-16, places=18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 3.55e-16, places=18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 1.74e-15, places=17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 3.87e-15, places=17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 4.84e-15, places=17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 1.04e-14, places=16)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[10].pvalue, 1.58e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[11].pvalue, 1.76e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[12].pvalue, 2.16e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[13].pvalue, 2.94e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[14].pvalue, 3.25e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[15].pvalue, 3.98e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[16].pvalue, 4.39e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[17].pvalue, 4.39e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[18].pvalue, 4.85e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[19].pvalue, 6.52e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[20].pvalue, 1.41e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[21].pvalue, 1.55e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[22].pvalue, 3.07e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[23].pvalue, 5.43e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[24].pvalue, 6.91e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[25].pvalue, 8.76e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[26].pvalue, 9.48e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[27].pvalue, 1.2e-11, places=12)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[28].pvalue, 1.19e-09, places=11
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[29].pvalue, 1.54e-09, places=11
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[30].pvalue, 1.99e-09, places=11
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[31].pvalue, 1.42e-06, places=8)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[32].pvalue, 3.43e-06, places=8)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_name, "BUDC_KLETE")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_name, "YINL_LISMO")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_name, "DHII_HUMAN")
|
||||
@ -3908,44 +3948,44 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.alt_id, "MEME-2")
|
||||
self.assertEqual(record["VGNPGASAYSASKAAVRGLTESLALELAP"], motif)
|
||||
self.assertEqual(motif.num_occurrences, 33)
|
||||
self.assertAlmostEqual(motif.evalue, 3.1e-130)
|
||||
self.assertAlmostEqual(motif.evalue, 3.1e-130, places=131)
|
||||
self.assertEqual(motif.alphabet, "ACDEFGHIKLMNPQRSTVWY")
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 33)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 2.09e-21)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 7.63e-20)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.49e-19)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.92e-18)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 5.46e-18)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 6.21e-18)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 4.52e-17)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 4.52e-17)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 9.21e-17)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 1.65e-16)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 2.07e-16)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 3.65e-16)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 5.7e-16)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 5.7e-16)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 7.93e-16)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 8.85e-16)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 1.1e-15)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 1.69e-15)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 3.54e-15)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 4.83e-15)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 7.27e-15)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 9.85e-15)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 2.41e-14)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 2.66e-14)
|
||||
self.assertAlmostEqual(motif.instances[24].pvalue, 1.22e-13)
|
||||
self.assertAlmostEqual(motif.instances[25].pvalue, 5.18e-13)
|
||||
self.assertAlmostEqual(motif.instances[26].pvalue, 1.24e-12)
|
||||
self.assertAlmostEqual(motif.instances[27].pvalue, 1.35e-12)
|
||||
self.assertAlmostEqual(motif.instances[28].pvalue, 5.59e-12)
|
||||
self.assertAlmostEqual(motif.instances[29].pvalue, 1.44e-10)
|
||||
self.assertAlmostEqual(motif.instances[30].pvalue, 1.61e-08)
|
||||
self.assertAlmostEqual(motif.instances[31].pvalue, 4.26e-08)
|
||||
self.assertAlmostEqual(motif.instances[32].pvalue, 1.16e-07)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 2.09e-21, places=23)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 7.63e-20, places=22)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.49e-19, places=21)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.92e-18, places=20)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 5.46e-18, places=20)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 6.21e-18, places=20)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 4.52e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 4.52e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 9.21e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 1.65e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 2.07e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 3.65e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 5.7e-16, places=17)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 5.7e-16, places=17)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 7.93e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 8.85e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 1.1e-15, places=16)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 1.69e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 3.54e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 4.83e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 7.27e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 9.85e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 2.41e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 2.66e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[24].pvalue, 1.22e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[25].pvalue, 5.18e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[26].pvalue, 1.24e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[27].pvalue, 1.35e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[28].pvalue, 5.59e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[29].pvalue, 1.44e-10, places=12)
|
||||
self.assertAlmostEqual(motif.instances[30].pvalue, 1.61e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[31].pvalue, 4.26e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[32].pvalue, 1.16e-07, places=9)
|
||||
self.assertEqual(motif.instances[0].sequence_name, "BUDC_KLETE")
|
||||
self.assertEqual(motif.instances[1].sequence_name, "NODG_RHIME")
|
||||
self.assertEqual(motif.instances[2].sequence_name, "FVT1_HUMAN")
|
||||
@ -4079,39 +4119,77 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.instances[31], "MGPEGVRVNAISAGPIRTLAASGIKDFRK")
|
||||
self.assertEqual(motif.instances[32], "RALKSCSPELQQKFRSETITEEELVGLMN")
|
||||
self.assertEqual(len(motif.alignment.sequences), 33)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 2.09e-21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 7.63e-20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.49e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.92e-18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 5.46e-18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 6.21e-18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 4.52e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 4.52e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 9.21e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 1.65e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[10].pvalue, 2.07e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[11].pvalue, 3.65e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[12].pvalue, 5.7e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[13].pvalue, 5.7e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[14].pvalue, 7.93e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[15].pvalue, 8.85e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 1.1e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[17].pvalue, 1.69e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[18].pvalue, 3.54e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[19].pvalue, 4.83e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[20].pvalue, 7.27e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[21].pvalue, 9.85e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[22].pvalue, 2.41e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[23].pvalue, 2.66e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[24].pvalue, 1.22e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[25].pvalue, 5.18e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[26].pvalue, 1.24e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[27].pvalue, 1.35e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[28].pvalue, 5.59e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[29].pvalue, 1.44e-10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[30].pvalue, 1.61e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[31].pvalue, 4.26e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[32].pvalue, 1.16e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 2.09e-21, places=23)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 7.63e-20, places=22)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.49e-19, places=21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.92e-18, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 5.46e-18, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 6.21e-18, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 4.52e-17, places=19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 4.52e-17, places=19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 9.21e-17, places=19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 1.65e-16, places=18)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[10].pvalue, 2.07e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[11].pvalue, 3.65e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[12].pvalue, 5.7e-16, places=17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[13].pvalue, 5.7e-16, places=17)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[14].pvalue, 7.93e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[15].pvalue, 8.85e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 1.1e-15, places=16)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[17].pvalue, 1.69e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[18].pvalue, 3.54e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[19].pvalue, 4.83e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[20].pvalue, 7.27e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[21].pvalue, 9.85e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[22].pvalue, 2.41e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[23].pvalue, 2.66e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[24].pvalue, 1.22e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[25].pvalue, 5.18e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[26].pvalue, 1.24e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[27].pvalue, 1.35e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[28].pvalue, 5.59e-12, places=14
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[29].pvalue, 1.44e-10, places=12
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[30].pvalue, 1.61e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[31].pvalue, 4.26e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[32].pvalue, 1.16e-07, places=9)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_name, "BUDC_KLETE")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_name, "NODG_RHIME")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_name, "FVT1_HUMAN")
|
||||
@ -4269,35 +4347,35 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.name, "GGFGGRPGKEVDLCYTYCALAALAJLGSLD")
|
||||
self.assertEqual(record["GGFGGRPGKEVDLCYTYCALAALAJLGSLD"], motif)
|
||||
self.assertEqual(motif.num_occurrences, 24)
|
||||
self.assertAlmostEqual(motif.evalue, 2.2e-94)
|
||||
self.assertAlmostEqual(motif.evalue, 2.2e-94, places=95)
|
||||
self.assertEqual(motif.alphabet, "ACDEFGHIKLMNPQRSTVWY")
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 24)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 6.98e-22)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 4.67e-21)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.25e-19)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.56e-19)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 2.44e-19)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 6.47e-19)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 8.9e-19)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 2.53e-18)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 1.27e-17)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 2.77e-17)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 4.93e-17)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 7.19e-17)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 8.68e-17)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 2.62e-16)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 2.87e-16)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 7.66e-15)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 2.21e-14)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 3.29e-14)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 7.21e-14)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 1.14e-13)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 1.67e-13)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 4.42e-13)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 5.11e-13)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 2.82e-10)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 6.98e-22, places=24)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 4.67e-21, places=23)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 1.25e-19, places=21)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 1.56e-19, places=21)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 2.44e-19, places=21)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 6.47e-19, places=21)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 8.9e-19, places=20)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 2.53e-18, places=20)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 1.27e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 2.77e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 4.93e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 7.19e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 8.68e-17, places=19)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 2.62e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 2.87e-16, places=18)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 7.66e-15, places=17)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 2.21e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 3.29e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 7.21e-14, places=16)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 1.14e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 1.67e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[21].pvalue, 4.42e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[22].pvalue, 5.11e-13, places=15)
|
||||
self.assertAlmostEqual(motif.instances[23].pvalue, 2.82e-10, places=12)
|
||||
self.assertEqual(motif.instances[0].sequence_name, "BET2_YEAST")
|
||||
self.assertEqual(motif.instances[1].sequence_name, "RATRABGERB")
|
||||
self.assertEqual(motif.instances[2].sequence_name, "CAL1_YEAST")
|
||||
@ -4443,30 +4521,58 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.instances[22], "PGLRDKPGAHSDFYHTNYCLLGLAVAESSY")
|
||||
self.assertEqual(motif.instances[23], "HNFEYWLTEHLRLNGIYWGLTALCVLDSPE")
|
||||
self.assertEqual(len(motif.alignment.sequences), 24)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 6.98e-22)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 4.67e-21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.25e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.56e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 2.44e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 6.47e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 8.9e-19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 2.53e-18)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 1.27e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 2.77e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[10].pvalue, 4.93e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[11].pvalue, 7.19e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[12].pvalue, 8.68e-17)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[13].pvalue, 2.62e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[14].pvalue, 2.87e-16)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[15].pvalue, 7.66e-15)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 2.21e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[17].pvalue, 3.29e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[18].pvalue, 7.21e-14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[19].pvalue, 1.14e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[20].pvalue, 1.67e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[21].pvalue, 4.42e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[22].pvalue, 5.11e-13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[23].pvalue, 2.82e-10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 6.98e-22, places=24)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 4.67e-21, places=23)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 1.25e-19, places=21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 1.56e-19, places=21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 2.44e-19, places=21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 6.47e-19, places=21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 8.9e-19, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 2.53e-18, places=20)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 1.27e-17, places=19)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 2.77e-17, places=19)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[10].pvalue, 4.93e-17, places=19
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[11].pvalue, 7.19e-17, places=19
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[12].pvalue, 8.68e-17, places=19
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[13].pvalue, 2.62e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[14].pvalue, 2.87e-16, places=18
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[15].pvalue, 7.66e-15, places=17
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[16].pvalue, 2.21e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[17].pvalue, 3.29e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[18].pvalue, 7.21e-14, places=16
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[19].pvalue, 1.14e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[20].pvalue, 1.67e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[21].pvalue, 4.42e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[22].pvalue, 5.11e-13, places=15
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[23].pvalue, 2.82e-10, places=12
|
||||
)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_name, "BET2_YEAST")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_name, "RATRABGERB")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_name, "CAL1_YEAST")
|
||||
@ -4645,30 +4751,42 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertEqual(motif.name, "JNKEKLLEYILSCQ")
|
||||
self.assertEqual(record["JNKEKLLEYILSCQ"], motif)
|
||||
self.assertEqual(motif.num_occurrences, 21)
|
||||
self.assertAlmostEqual(motif.evalue, 3.1e-19)
|
||||
self.assertAlmostEqual(motif.evalue, 6.1e-21, places=22)
|
||||
self.assertEqual(motif.alphabet, "ACDEFGHIKLMNPQRSTVWY")
|
||||
self.assertEqual(len(motif.alignment.sequences), 21)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 2.71e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 5.7e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.43e-12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.61e-11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 6.3e-11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 2.7e-10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 4.03e-10)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 1.27e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 3.17e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 6.39e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[10].pvalue, 6.96e-09)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[11].pvalue, 1.06e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[12].pvalue, 1.26e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[13].pvalue, 1.37e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[14].pvalue, 2.07e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[15].pvalue, 4.96e-08)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 1.15e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[17].pvalue, 1.44e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[18].pvalue, 1.55e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[19].pvalue, 1.93e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[20].pvalue, 5.2e-07)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[0].pvalue, 2.71e-12, places=14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[1].pvalue, 5.7e-12, places=13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[2].pvalue, 6.43e-12, places=14)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[3].pvalue, 2.61e-11, places=13)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[4].pvalue, 6.3e-11, places=12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[5].pvalue, 2.7e-10, places=11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[6].pvalue, 4.03e-10, places=12)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[7].pvalue, 1.27e-09, places=11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[8].pvalue, 3.17e-09, places=11)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[9].pvalue, 6.39e-09, places=11)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[10].pvalue, 6.96e-09, places=11
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[11].pvalue, 1.06e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[12].pvalue, 1.26e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[13].pvalue, 1.37e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[14].pvalue, 2.07e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
motif.alignment.sequences[15].pvalue, 4.96e-08, places=10
|
||||
)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[16].pvalue, 1.15e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[17].pvalue, 1.44e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[18].pvalue, 1.55e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[19].pvalue, 1.93e-07, places=9)
|
||||
self.assertAlmostEqual(motif.alignment.sequences[20].pvalue, 5.2e-07, places=8)
|
||||
self.assertEqual(motif.alignment.sequences[0].sequence_name, "RATRABGERB")
|
||||
self.assertEqual(motif.alignment.sequences[1].sequence_name, "BET2_YEAST")
|
||||
self.assertEqual(motif.alignment.sequences[2].sequence_name, "RATRABGERB")
|
||||
@ -4798,27 +4916,27 @@ class TestMEME(unittest.TestCase):
|
||||
# using the old instances property:
|
||||
with self.assertWarns(BiopythonDeprecationWarning):
|
||||
self.assertEqual(len(motif.instances), 21)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 2.71e-12)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 5.7e-12)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.43e-12)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.61e-11)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 6.3e-11)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 2.7e-10)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 4.03e-10)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 1.27e-09)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 3.17e-09)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 6.39e-09)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 6.96e-09)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 1.06e-08)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 1.26e-08)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 1.37e-08)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 2.07e-08)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 4.96e-08)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 1.15e-07)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 1.44e-07)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 1.55e-07)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 1.93e-07)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 5.2e-07)
|
||||
self.assertAlmostEqual(motif.instances[0].pvalue, 2.71e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[1].pvalue, 5.7e-12, places=13)
|
||||
self.assertAlmostEqual(motif.instances[2].pvalue, 6.43e-12, places=14)
|
||||
self.assertAlmostEqual(motif.instances[3].pvalue, 2.61e-11, places=13)
|
||||
self.assertAlmostEqual(motif.instances[4].pvalue, 6.3e-11, places=12)
|
||||
self.assertAlmostEqual(motif.instances[5].pvalue, 2.7e-10, places=11)
|
||||
self.assertAlmostEqual(motif.instances[6].pvalue, 4.03e-10, places=12)
|
||||
self.assertAlmostEqual(motif.instances[7].pvalue, 1.27e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[8].pvalue, 3.17e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[9].pvalue, 6.39e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[10].pvalue, 6.96e-09, places=11)
|
||||
self.assertAlmostEqual(motif.instances[11].pvalue, 1.06e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[12].pvalue, 1.26e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[13].pvalue, 1.37e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[14].pvalue, 2.07e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[15].pvalue, 4.96e-08, places=10)
|
||||
self.assertAlmostEqual(motif.instances[16].pvalue, 1.15e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[17].pvalue, 1.44e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[18].pvalue, 1.55e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[19].pvalue, 1.93e-07, places=9)
|
||||
self.assertAlmostEqual(motif.instances[20].pvalue, 5.2e-07, places=8)
|
||||
self.assertEqual(motif.instances[0].sequence_name, "RATRABGERB")
|
||||
self.assertEqual(motif.instances[1].sequence_name, "BET2_YEAST")
|
||||
self.assertEqual(motif.instances[2].sequence_name, "RATRABGERB")
|
||||
@ -4966,7 +5084,7 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertAlmostEqual(motif.background["C"], 0.1828171828171828)
|
||||
self.assertAlmostEqual(motif.background["G"], 0.20879120879120877)
|
||||
self.assertAlmostEqual(motif.background["T"], 0.30569430569430567)
|
||||
self.assertAlmostEqual(motif.evalue, 4.1e-09)
|
||||
self.assertAlmostEqual(motif.evalue, 4.1e-09, places=10)
|
||||
self.assertEqual(motif.alphabet, "ACGT")
|
||||
self.assertIsNone(motif.alignment)
|
||||
# using the old instances property:
|
||||
@ -5012,7 +5130,7 @@ class TestMEME(unittest.TestCase):
|
||||
self.assertAlmostEqual(motif.background["C"], 0.1828171828171828)
|
||||
self.assertAlmostEqual(motif.background["G"], 0.20879120879120877)
|
||||
self.assertAlmostEqual(motif.background["T"], 0.30569430569430567)
|
||||
self.assertAlmostEqual(motif.evalue, 4.1e-09)
|
||||
self.assertAlmostEqual(motif.evalue, 3.2e-35, places=36)
|
||||
self.assertEqual(motif.alphabet, "ACGT")
|
||||
self.assertIsNone(motif.alignment)
|
||||
self.assertEqual(motif.consensus, "TACTGTATATATATCCAG")
|
||||
|
||||
@ -32,7 +32,7 @@ class TestAlignerProperties(unittest.TestCase):
|
||||
aligner.epsilon = 1.0e-4
|
||||
self.assertAlmostEqual(aligner.epsilon, 1.0e-4)
|
||||
aligner.epsilon = 1.0e-8
|
||||
self.assertAlmostEqual(aligner.epsilon, 1.0e-8)
|
||||
self.assertAlmostEqual(aligner.epsilon, 1.0e-8, places=8)
|
||||
with self.assertRaises(TypeError):
|
||||
aligner.epsilon = "not a number"
|
||||
with self.assertRaises(TypeError):
|
||||
|
||||
Reference in New Issue
Block a user