| None | '
'A'
'C'
'G'
'G'
'T'
'G'
'G'
'G'
'G'
'G'
'G'
'G'
'G'
'G |
'
)
self.assertTrue(seq_row in got)
def test_repr_html(self):
"""correctly uses set_repr and the environment variable settings"""
token = 'class="label"'
seq = self.SEQ("AAAAA")
orig = [l for l in seq._repr_html_().splitlines() if token in l][0]
orig_num = len(re.findall(r"\bA\b", orig))
self.assertEqual(orig_num, 5)
# using environment variable
env_name = "COGENT3_ALIGNMENT_REPR_POLICY"
os.environ[env_name] = "num_pos=2"
got = [l for l in seq._repr_html_().splitlines() if token in l][0]
got_num = len(re.findall(r"\bA\b", got))
self.assertEqual(got_num, 2)
os.environ.pop(env_name, None)
def test_add(self):
"""Test for the add method within sequence"""
even = "TCAGAT"
odd = even + "AAA"
original_sequence = self.SEQ(even, name="even")
duplicate_sequence = self.SEQ(even, name="even")
name_only_duplicate = self.SEQ(even, name="odd")
different_sequence = self.SEQ(odd, name="odd")
added_duplicates = original_sequence + duplicate_sequence
added_name_only_duplicate = original_sequence + name_only_duplicate
different_sequences = original_sequence + different_sequence
self.assertIsNone(different_sequences.name)
self.assertIsNotNone(added_duplicates.name)
self.assertIsNotNone(added_name_only_duplicate)
self.assertEqual(original_sequence.name, added_duplicates.name)
self.assertNotEqual(original_sequence.name, added_name_only_duplicate.name)
self.assertNotEqual(original_sequence.name, different_sequences.name)
def test_add2(self):
"""name property correctly handled in sequence add"""
a1 = self.SEQ("AAA", name="1")
a2 = self.SEQ("CC", name="1")
a = a1 + a2
self.assertEqual(a.name, "1")
self.assertEqual(a, "AAACC")
b = self.SEQ("GGGG", name="2")
self._check_mix_add(a1, b)
c = self.SEQ("TT")
self._check_mix_add(a1, c)
e = "AA"
be = b + e
self.assertIsNone(be.name)
self.assertEqual(be, str(b) + e)
def _check_mix_add(self, s1, s2):
s1s2 = s1 + s2
s2s1 = s2 + s1
self.assertIsNone(s1s2.name)
self.assertIsNone(s2s1.name)
self.assertEqual(s1s2, str(s1) + str(s2))
self.assertEqual(s2s1, str(s2) + str(s1))
class SequenceSubclassTests(TestCase):
SequenceClass = Sequence
def test_DnaSequence(self):
"""DnaSequence should behave as expected"""
x = DnaSequence("tcag")
# note: no longer preserves case
self.assertEqual(x, "TCAG")
x = DnaSequence("aaa") + DnaSequence("ccc")
# note: doesn't preserve case
self.assertEqual(x, "AAACCC")
assert x.moltype is DNA
self.assertRaises(AlphabetError, x.__add__, "z")
self.assertEqual(DnaSequence("TTTAc").rc(), "GTAAA")
def test_get_type(self):
"""returns moltype label"""
for moltype in ("text", "dna", "bytes"):
seq = get_moltype(moltype).make_seq("ARCGT")
self.assertEqual(seq.get_type(), moltype)
def test_resolved_ambiguities(self):
seq = get_moltype("dna").make_seq("ARC")
got = seq.resolved_ambiguities()
self.assertEqual(got, [("A",), ("A", "G"), ("C",)])
seq = get_moltype("dna").make_seq("AGC")
got = seq.resolved_ambiguities()
self.assertEqual(got, [("A",), ("G",), ("C",)])
def test_iter_kmers(self):
"""correctly yield all k-mers"""
from typing import Generator
orig = "TCAGGA"
r = self.SequenceClass(orig)
self.assertIsInstance(r.iter_kmers(k=1), Generator)
for k in range(1, 7):
expect = [str(orig[i : i + k]) for i in range(len(orig) - k + 1)]
got = list(r.iter_kmers(k))
self.assertEqual(got, expect)
orig = ""
r = self.SequenceClass(orig)
self.assertIsInstance(r.iter_kmers(k=1), Generator)
got = list(r.iter_kmers(k=1))
self.assertEqual(got, [])
def test_iter_kmers_handles_invalid(self):
"""raise exceptions on invalid input to iter_kmers"""
orig = "TCAGGA"
r = self.SequenceClass(orig)
for k in (0, -1, 1.1):
with self.assertRaises(ValueError):
_ = list(r.iter_kmers(k))
def test_get_kmers(self):
"""returns a list of k-mers"""
orig = "TCAGGA"
r = self.SequenceClass(orig)
for k in range(1, 7):
expect = [str(orig[i : i + k]) for i in range(len(orig) - k + 1)]
got = r.get_kmers(k)
self.assertEqual(got, expect)
# TODO move methods of this class onto the single class that inherits from it!
class ModelSequenceTests(object):
"""base class for tests of specific ArraySequence objects."""
SequenceClass = None # override in derived classes
def test_to_fasta(self):
"""Sequence to_fasta() should return Fasta-format string"""
even = "TCAGAT"
odd = even + "AAA"
even_dna = self.SequenceClass(even, name="even")
odd_dna = self.SequenceClass(odd, name="odd")
self.assertEqual(even_dna.to_fasta(), ">even\nTCAGAT\n")
# set line wrap to small number so we can test that it works
self.assertEqual(even_dna.to_fasta(block_size=2), ">even\nTC\nAG\nAT\n")
self.assertEqual(odd_dna.to_fasta(block_size=2), ">odd\nTC\nAG\nAT\nAA\nA\n")
# check that changing the linewrap again works
self.assertEqual(even_dna.to_fasta(block_size=4), ">even\nTCAG\nAT\n")
def test_to_phylip(self):
"""Sequence to_phylip() should return one-line phylip string"""
s = self.SequenceClass("ACG", name="xyz")
self.assertEqual(s.to_phylip(), "xyz" + " " * 27 + "ACG")
class DnaSequenceTests(ModelSequenceTests, TestCase):
class SequenceClass(ArrayNucleicAcidSequence):
alphabet = DNA.alphabets.base
def test_init(self):
"""Sequence should do round-trip from string"""
orig = ""
r = self.SequenceClass(orig)
self.assertEqual(str(r), orig)
orig = "TCAGGA"
r = self.SequenceClass(orig)
assert_equal(r._data, array([0, 1, 2, 3, 3, 2]))
self.assertEqual(str(r), orig)
class CodonSequenceTests(SequenceTests, TestCase):
class SequenceClass(ArrayCodonSequence):
alphabet = DNA.alphabets.base ** 3
def test_init(self):
"""Sequence should do round-trip from string"""
orig = ""
r = self.SequenceClass(orig)
self.assertEqual(str(r), orig)
orig = "TCAGGA"
r = self.SequenceClass(orig)
assert_equal(r._data, array([6, 62]))
self.assertEqual(str(r), orig)
class DnaSequenceGapTests(TestCase):
"""Tests of gapped DNA sequences."""
class SequenceClass(ArrayNucleicAcidSequence):
alphabet = DNA.alphabets.gapped
gap = "-"
def test_init(self):
"""gapped sequence should init ok"""
orig = "TC---"
seq = self.SequenceClass(orig)
self.assertEqual(str(seq), orig)
def test_gaps(self):
"""gapped sequence gaps() should return correct array"""
sc = self.SequenceClass
assert_equal(sc("TC").gaps(), array([0, 0]))
assert_equal(sc("T-").gaps(), array([0, 1]))
def test_degap(self):
"""gapped sequence degap() should return correct array"""
sc = self.SequenceClass
self.assertEqual(sc("T-").degap(), sc("T"))
def test_nongaps(self):
"""gapped sequence nongaps() should return correct array"""
sc = self.SequenceClass
assert_equal(sc("TC").nongaps(), array([1, 1]))
assert_equal(sc("T-").nongaps(), array([1, 0]))
def test_regap(self):
"""gapped sequence regap() should return correct sequence"""
sc = self.SequenceClass
self.assertEqual(str(sc("TC").regap(sc("A---A-"))), "T---C-")
def test_degap_name(self):
"""degap preserves name attribute"""
# todo this should work for any seq class, but is not
seq = DNA.make_seq("ACG---T", "blah")
got = seq.degap()
self.assertEqual(str(got), "ACGT")
self.assertEqual(got.name, "blah")
class SequenceIntegrationTests(TestCase):
"""Should be able to convert regular to model sequences, and back"""
def test_regular_to_model(self):
"""Regular sequence should convert to model sequence"""
r = RNA.make_seq("AAA", name="x")
s = RNA.make_array_seq(r)
self.assertEqual(str(s), "AAA")
self.assertEqual(s.moltype, RNA)
self.assertEqual(s.name, "x")
def test_model_to_regular(self):
"""Model sequence should convert to regular sequence"""
r = RNA.make_array_seq("AAA", name="x")
s = RNA.make_seq(r)
self.assertEqual(str(s), "AAA")
self.assertEqual(s.moltype, RNA)
self.assertEqual(s.name, "x")
def test_regular_to_regular(self):
"""Regular sequence should convert to regular sequence"""
r = RNA.make_seq("AAA", name="x")
s = RNA.make_seq(r)
self.assertEqual(str(s), "AAA")
self.assertEqual(s.moltype, RNA)
self.assertEqual(s.name, "x")
def test_model_to_model(self):
"""Model sequence should convert to model sequence"""
r = RNA.make_array_seq("AAA", name="x")
s = RNA.make_array_seq(r)
self.assertEqual(str(s), "AAA")
self.assertEqual(s.moltype, RNA)
self.assertEqual(s.name, "x")
def test_ModelDnaCodonSequence(self):
"""ArrayDnaCodonSequence should behave as expected"""
d = ArrayDnaCodonSequence("UUUCGU")
self.assertEqual(str(d), "TTTCGT")
assert_equal(d._data, array([0, 28]))
self.assertEqual(str(d.to_rna()), "UUUCGU")
self.assertEqual(str(d.to_dna()), "TTTCGT")
def test_ModelRnaCodonSequence(self):
"""ArrayRnaCodonSequence should behave as expected"""
r = ArrayRnaCodonSequence("UUUCGU")
self.assertEqual(str(r), "UUUCGU")
assert_equal(r._data, array([0, 28]))
self.assertEqual(str(r.to_rna()), "UUUCGU")
self.assertEqual(str(r.to_dna()), "TTTCGT")
class ModelSequenceTests(SequenceTests):
"""Tests of the ArraySequence class's inheritance of SequenceI."""
SEQ = ArraySequence
RNA = ArrayRnaSequence
DNA = ArrayDnaSequence
PROT = ArrayProteinSequence
AB = ABSequence
def test_distance_indices(self):
"""ArraySequence distance should work with function of indices"""
s1 = self.RNA("AUGC")
s2 = self.RNA("AAGC")
def f(x, y):
if x == 2 or y == 2:
return 10
return 0
self.assertEqual(s1.distance(s2, f, use_indices=True), 20)
def test_strip_bad(self):
"""Sequence strip_bad should remove any non-base, non-gap chars"""
# have to turn off check to get bad data in; no longer preserves case
r = self.RNA("UCAGRYU")
r._data[0] = 31
r._data[2] = 55
self.assertEqual(r.strip_bad(), "CGRYU")
def test_strip_bad_and_gaps(self):
"""Sequence strip_bad_and_gaps should remove gaps and bad chars"""
# have to turn off check to get bad data in; no longer preserves case
r = self.RNA("ACG--GRN?")
self.assertEqual(r.strip_bad_and_gaps(), "ACGGRN")
r._data[0] = 99
self.assertEqual(r.strip_bad_and_gaps(), "CGGRN")
def test_gap_array(self):
"""Sequence gap_array should return array of gaps"""
r = self.RNA("-?A-?NRY-")
v = r.gap_array()
assert_equal(v, array([1, 1, 0, 1, 1, 0, 0, 0, 1]))
r = self.RNA("AC")
v = r.gap_array()
assert_equal(v, array([0, 0]))
r = self.RNA("-?")
v = r.gap_array()
assert_equal(v, array([1, 1]))
def test_gap_indices(self):
"""Sequence gap_indices should return positions of gaps"""
r = self.RNA("-?A-?NRY-")
v = r.gap_indices()
assert_equal(v, array([0, 1, 3, 4, 8]))
r = self.RNA("AC")
v = r.gap_indices()
assert_equal(v, array([])) # note: always returns array
r = self.RNA("-?")
v = r.gap_indices()
assert_equal(v, array([0, 1]))
def test_count_ab(self):
"""abseq array seq should count characters"""
AB = get_moltype("ab")
seq = AB.make_array_seq("aaba-", alphabet=AB.alphabet.with_gap_motif())
c = seq.counts()
self.assertEqual(c.to_dict(), {"a": 3, "b": 1})
c = seq.counts(allow_gap=True)
self.assertEqual(c.to_dict(), {"a": 3, "b": 1, "-": 1})
# run if called from command-line
if __name__ == "__main__":
main()