def test_getitem(self): """PositionalBaseUsage getitem should return 1st, 2nd, 3rd in order""" a, c, g = BaseUsage('A'), BaseUsage('C'), BaseUsage('G') p = PositionalBaseUsage(a, c, g) assert p.First is a assert p.Second is c assert p.Third is g #make sure they're not all the same object assert p.First is not g #test positive indices assert p[0] is p.First assert p[1] is p.Second assert p[2] is p.Third #test negative indices assert p[-1] is p.Third assert p[-2] is p.Second assert p[-3] is p.First try: x = p[3] except IndexError: pass else: self.fail("Failed to raise IndexError on bad index") #test iteration for o, e in zip(p, [a, c, g]): assert o is e
def test_add(self): """BaseUsage add should sum two base usages""" b = BaseUsage('U') b2 = BaseUsage('C') self.assertEqual(b + b2, BaseUsage('UC')) b += b2 self.assertEqual(b, BaseUsage('UC'))
def test_toCartesian(self): """BaseUsage toCartesian should return x, y, z from instance""" b = BaseUsage('ACGU') self.assertEqual(b.toCartesian(), (0.5, 0.5, 0.5)) b = BaseUsage('A') self.assertEqual(b.toCartesian(), (0, 0, 1)) b = BaseUsage('CGA') self.assertEqual(b.toCartesian(), (1 / 3.0, 1 / 3.0, 1 / 3.0))
def test_bases(self): """CodonUsage bases should count bases correctly""" u = CodonUsage('UUUCCCUAGCCCGGGAA') b = u.bases() self.assertEqual(b, BaseUsage('UUUCCCUAGCCCGGGAA')) #purge_unwanted should get rid of bad codons b = u.bases(purge_unwanted=True) self.assertEqual(b, BaseUsage('UUUCCCCCCGGG'))
def test_normalize(self): """BaseUsage normalize should work when empty""" b = BaseUsage() b.normalize() self.assertEqual(b, {'U': 0, 'C': 0, 'A': 0, 'G': 0}) b = BaseUsage('AACG') b.normalize() self.assertEqual(b, {'U': 0, 'C': 0.25, 'A': 0.5, 'G': 0.25})
def test_normalize(self): """PositionalBaseUsage normalize should normalize each position""" a, c, g = BaseUsage('AAGC'), BaseUsage('CCGA'), BaseUsage('GGCA') p = PositionalBaseUsage(a, c, g) self.assertEqual(p[0], {'A': 2, 'C': 1, 'G': 1, 'U': 0}) p.normalize() self.assertEqual(p[0], {'A': 0.5, 'C': 0.25, 'G': 0.25, 'U': 0}) self.assertEqual(p[1], {'A': 0.25, 'C': 0.5, 'G': 0.25, 'U': 0}) self.assertEqual(p[2], {'A': 0.25, 'C': 0.25, 'G': 0.5, 'U': 0})
def test_positionalBases(self): """BaseUsage positionalBases should have copy of self at each position""" b = BaseUsage('A') p = b.positionalBases() for i in p: assert i is not b self.assertEqual(i, {'A': 1, 'U': 0, 'C': 0, 'G': 0})
def test_getitem_multi(self): """BaseUsage should get total frequency on getitem with 2-letter key""" b = BaseUsage({'a': 3, 'T': 2, 'C': 5, 'X': 1}) self.assertEqual(b['AT'], 0.5) self.assertEqual(b['AC'], 0.8) self.assertEqual(b['TC'], 0.7) self.assertEqual(b['AX'], 0.3)
def test_init_empty(self): """PositionalBaseUsage init when empty should set all freqs to 0""" p = PositionalBaseUsage() assert p[0] is not p[1] assert p[1] is not p[2] assert p[0] is not p[2] for i in p: self.assertEqual(i, BaseUsage())
def test_setitem(self): """BaseUsage should map keys on setitem""" b = BaseUsage() b['t'] = 3 b['G'] = 3 b.normalize() i = b.items() i.sort() self.assertEqual(i, [('A', 0.0), ('C', 0.0), ('G', 0.5), ('U', 0.5)])
def test_getitem(self): """BaseUsage should map key on getitem""" b = BaseUsage({'a': 3, 'T': 2, 'X': 1}) self.assertEqual(b['X'], 1) self.assertEqual(b['A'], 3) self.assertEqual(b['U'], 2) self.assertEqual(b['a'], 3) self.assertEqual(b['t'], 2) b.normalize() assert 'X' not in b self.assertFloatEqual(b['A'], 0.6) self.assertFloatEqual(b['u'], 0.4)
def test_content(self): """BaseUsage content should return sum of specified bases.""" b = BaseUsage('UUUUUCCCAG') #should work for combinations self.assertEqual(b.content('UCAG'), 10) self.assertEqual(b.content('GC'), 4) self.assertEqual(b.content('AU'), 6) #should map T to U self.assertEqual(b.content('AT'), 6) #should work for single bases self.assertEqual(b.content('U'), 5) #shouldn't complain about invalid bases self.assertEqual(b.content('X'), 0)
def test_init_empty(self): """BaseUsage should init with empty freqs""" b = BaseUsage() self.assertEqual(len(b), 4) for nt in 'UTACGutacg': assert nt in b self.assertEqual(b[nt], 0) for nt in 'UCAG': assert nt in b.keys() items = list(iter(b)) items.sort() self.assertEqual(items, ['A', 'C', 'G', 'U'])
def test_positionalBases(self): """CodonUsage bases should count bases at each position correctly""" freqs = { 'UUC': 5, 'AUA': 10, 'AUG': 10, 'CGC': 3, 'AGG': 2, 'XYZ': 8, 'UAA': 2, 'UGA': 1 } u = CodonUsage(freqs) b = u.positionalBases() assert isinstance(b, PositionalBaseUsage) first, second, third = b self.assertEqual(first, BaseUsage({'U': 8, 'C': 3, 'A': 22, 'X': 8})) self.assertEqual(second, BaseUsage({ 'U': 25, 'C': 0, 'A': 2, 'G': 6, 'Y': 8 })) self.assertEqual(third, BaseUsage({'C': 8, 'A': 13, 'G': 12, 'Z': 8})) #check that it also works when we purge p = u.positionalBases(purge_unwanted=True) first, second, third = p self.assertEqual(first, BaseUsage({'U': 5, 'C': 3, 'A': 2})) self.assertEqual(second, BaseUsage({'U': 5, 'G': 5})) self.assertEqual(third, BaseUsage({'C': 8, 'G': 2})) #check that it also works with a different genetic code, and, #incidentally, that the purging didn't affect the original object u.GeneticCode = GeneticCodes[2] #mt code: different stop codons p = u.positionalBases(purge_unwanted=True) first, second, third = p self.assertEqual(first, BaseUsage({'U': 6, 'C': 3, 'A': 20})) self.assertEqual(second, BaseUsage({'U': 25, 'G': 4})) self.assertEqual(third, BaseUsage({'C': 8, 'A': 11, 'G': 10}))
def test_aminoAcids(self): """BaseUsage aminoAcids should give the same results as the codons""" known_data = { 'AAA': .6 * .6 * .6, 'AAU': .6 * .6 * .4, 'AUA': .6 * .4 * .6, 'AUU': .6 * .4 * .4, 'UAA': .4 * .6 * .6, 'UAU': .4 * .6 * .4, 'UUA': .4 * .4 * .6, 'UUU': .4 * .4 * .4, } known = CodonUsage(known_data) b = BaseUsage({'a': 3, 'T': 2, 'X': 1}) self.assertEqual(b.aminoAcids(), known.aminoAcids()) #check that the genetic code is passed through correctly all_g = GeneticCode('G' * 64) self.assertEqual(b.aminoAcids(all_g), AminoAcidUsage({'G': 1}))
def test_codons(self): """BaseUsage codons should return most likely codon freqs""" b = BaseUsage({'a': 3, 'T': 2, 'X': 1}) c = b.codons() known = { 'AAA': .6 * .6 * .6, 'AAU': .6 * .6 * .4, 'AUA': .6 * .4 * .6, 'AUU': .6 * .4 * .4, 'UAA': .4 * .6 * .6, 'UAU': .4 * .6 * .4, 'UUA': .4 * .4 * .6, 'UUU': .4 * .4 * .4, } for codon in c: if codon in known: self.assertFloatEqual(c[codon], known[codon]) else: self.assertEqual(c[codon], 0)
def test_MagePointFromBaseFreqs_usage(self): """MagePoint should init correctly from base freqs""" class fake_seq(str, Delegator): def __new__(cls, data, *args): return str.__new__(cls, data) def __init__(self, data, *args): Delegator.__init__(self, *args) self.__dict__['Info'] = self._handler str.__init__(data) class has_species(object): def __init__(self, sp): self.Species = sp s = fake_seq('AAAAACCCTG', has_species('H**o sapiens')) b = BaseUsage(s) p = MagePointFromBaseFreqs(b) self.assertEqual(str(p), '{H**o sapiens} 0.5 0.3 0.1')
def test_bases(self): """PositionalBaseUsage bases should sum bases at each position""" a, c, g = BaseUsage('AAGC'), BaseUsage('CCGA'), BaseUsage('GGCA') p = PositionalBaseUsage(a, c, g) b = p.bases() self.assertEqual(b, BaseUsage('AAGCCCGAGGCA'))
def test_init_data(self): """BaseUsage should init with arbitrary data""" b = BaseUsage('UUUUUGGGCA') self.assertEqual(b, {'U': 5, 'G': 3, 'C': 1, 'A': 1}) b.normalize() self.assertEqual(b, {'U': 0.5, 'G': 0.3, 'C': 0.1, 'A': 0.1})
def test_bases(self): """BaseUsage bases() should return same object""" b = BaseUsage({'a': 3, 'T': 2, 'C': 5, 'X': 1}) c = b.bases() assert b is c
def test_copy(self): """BaseUsage copy should work correctly""" b = BaseUsage({'a': 3, 'T': 2, 'C': 5, 'X': 1}) c = b.copy() self.assertEqual(c['AT'], 0.5)
def test_distance(self): """BaseUsage distance() should return dist between two BUs""" #absolute numbers, will normalize to calculate distance self.assertFloatEqual(BaseUsage('GC').distance(BaseUsage('AU')), 1) self.assertFloatEqual(BaseUsage('AU').distance(BaseUsage('GC')), 1) self.assertFloatEqual( BaseUsage('GCAU').distance(BaseUsage('AUAU')), .5) #should work even against dict with 'T's self.assertFloatEqual(BaseUsage('GCAU').distance(\ BaseUsage({'A':2,'T':2,'C':0,'G':0,})),.5) #rounding error self.assertEqual(BaseUsage('ACG').distance(BaseUsage('CCGGAA')), 0) #normalized - as in unit simplex ag = BaseUsage('AG') ag.normalize() uc = BaseUsage('UC') uc.normalize() self.assertFloatEqual(ag.distance(uc), 1) self.assertFloatEqual(BaseUsage({'A':0.4,'G':0.1,'C':0.4,'U':0.1})\ .distance(BaseUsage({'A':0.1,'G':0.4,'U':0.4,'C':0.1})),0.6) self.assertFloatEqual(BaseUsage({'A':0.25,'G':0.25,'C':0.25,'U':0.25})\ .distance(BaseUsage({'A':0.25,'G':0.25,'U':0.25,'C':0.25})),0.0) self.assertFloatEqual(BaseUsage({'A':0.245,'G':0.255,'C':0.245,\ 'U':0.255}).distance(BaseUsage({'A':0.255,'G':0.245,'U':0.245,\ 'C':0.255})),0.02) self.assertFloatEqual(BaseUsage({'A':0.245,'G':0.255,'C':0.245,\ 'U':0.255}).distance(BaseUsage({'A':0.25,'G':0.25,'U':0.25,\ 'C':0.25})),0.01) self.assertFloatEqual(BaseUsage({'A':0.248,'G':0.252,'C':0.248,\ 'U':0.252}).distance(BaseUsage({'A':0.25,'G':0.25,'U':0.25,\ 'C':0.25})),0.004)