Esempio n. 1
0
 def test_create_tree(self):
     """take tax strings, create a tree"""
     exp = {'name':'root',
             'popcount':3, 
             'children':[
                 {'name':'k__1',
                  'popcount':3,
                  'children':[
                     {'name':'p__x', 
                      'popcount':2,
                      'children':[
                         {'name':'c__1', 
                          'popcount':1, 
                          'children':[]},
                         {'name':'c__2', 
                          'popcount':1, 
                          'children':[]}
                         ]
                     },
                     {'name':'p__y',
                      'popcount':3,
                      'children':[
                          {'name':'c__3',
                           'popcount':2,
                           'children':[]}
                          ]
                      }
                 ]}
             ]}
     tax_strings = deepcopy(tax_strings_by_sample)
     tax_strings[0].append(['k__[1]','p__x','c__'])
     obs = update_tree(None, tax_strings)
     self.assertEqual(obs, exp)
Esempio n. 2
0
 def test_create_tree(self):
     """take tax strings, create a tree"""
     exp = {'name':'root',
             'popcount':3, 
             'children':[
                 {'name':'k__1',
                  'popcount':3,
                  'children':[
                     {'name':'p__x', 
                      'popcount':2,
                      'children':[
                         {'name':'c__1', 
                          'popcount':1, 
                          'children':[]},
                         {'name':'c__2', 
                          'popcount':1, 
                          'children':[]}
                         ]
                     },
                     {'name':'p__y',
                      'popcount':3,
                      'children':[
                          {'name':'c__3',
                           'popcount':2,
                           'children':[]}
                          ]
                      }
                 ]}
             ]}
     obs = update_tree(None, tax_strings_by_sample)
     self.assertEqual(obs, exp)
Esempio n. 3
0
 def test_create_tree_ignore_contested(self):
     """take tax strings, create a tree"""
     exp = {'name':'root',
             'popcount':3, 
             'children':[
                 {'name':'k__1',
                  'popcount':3,
                  'children':[
                     {'name':'p__x', 
                      'popcount':2,
                      'children':[
                         {'name':'c__1', 
                          'popcount':1, 
                          'children':[]},
                         {'name':'c__2', 
                          'popcount':1, 
                          'children':[]}
                         ]
                     },
                     {'name':'p__y',
                      'popcount':3,
                      'children':[
                          {'name':'c__3',
                           'popcount':2,
                           'children':[]}
                          ]
                      }
                 ]}
             ]}
     obs = update_tree(None, tax_strings_by_sample)
     self.assertEqual(obs, exp)
Esempio n. 4
0
    def test_get_rare_unique(self):
        t = update_tree(None, tax_strings_by_sample)
        exp_unique = [['k__1','p__x','c__2']]
        exp_rare = [['k__1','p__x','c__'],['k__1','p__y','c__3']]
        obs_rare, obs_unique = get_rare_unique(t, sample_taxa, 0.7)
        
        self.assertEqual(obs_rare, exp_rare)
        self.assertEqual(obs_unique, exp_unique)

        exp_unique = [['k__1','p__x','c__2']]
        exp_rare = []
        obs_rare, obs_unique = get_rare_unique(t, sample_taxa, 0.4)

        self.assertEqual(obs_rare, exp_rare)
        self.assertEqual(obs_unique, exp_unique)
    def test_get_rare_unique(self):
        t = update_tree(None, tax_strings_by_sample)
        exp_unique = [['k__1', 'p__x', 'c__2']]
        exp_rare = [['k__1', 'p__x', 'c__'], ['k__1', 'p__y', 'c__3']]
        obs_rare, obs_unique = get_rare_unique(t, sample_taxa, 0.7)

        self.assertEqual(obs_rare, exp_rare)
        self.assertEqual(obs_unique, exp_unique)

        exp_unique = [['k__1', 'p__x', 'c__2']]
        exp_rare = []
        obs_rare, obs_unique = get_rare_unique(t, sample_taxa, 0.4)

        self.assertEqual(obs_rare, exp_rare)
        self.assertEqual(obs_unique, exp_unique)
    def test_sample_rare_unique(self):
        t = update_tree(None, tax_strings_by_sample)
        tax_by_sample = {
            'a': tax_strings_by_sample[0],
            'b': tax_strings_by_sample[1],
            'c': tax_strings_by_sample[2]
        }
        exp = [('a', None, [['k__1', 'p__x', 'c__'],
                            ['k__1', 'p__y',
                             'c__3']], [['k__1', 'p__x', 'c__1'],
                                        ['k__1', 'p__x', 'c__2']]),
               ('b', None, [['k__1', 'p__x', 'c__'], ['k__1', 'p__y',
                                                      'c__3']], []),
               ('c', None, [], [])]
        obs = sample_rare_unique(t, None, tax_by_sample, 0.7)
        self.assertEqual(sorted(obs), exp)

        table_a = Table(array([[14, 15, 16]]), ['k__1; p__y; c__'],
                        ['a', 'b', 'c'])
        table_b = Table(
            array([[1, 2, 3], [4, 5, 6], [14, 15, 16]]),
            ['k__1; p__x; c__1', 'k__1; p__x; c__2', 'k__1; p__y; c__'],
            ['a', 'b', 'c'],
        )
        table_c = Table(
            array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12],
                   [14, 15, 16]]), [
                       'k__1; p__x; c__1', 'k__1; p__x; c__2',
                       'k__1; p__x; c__', 'k__1; p__y; c__3', 'k__1; p__y; c__'
                   ], ['a', 'b', 'c'])

        exp = [('a', table_a, [['k__1', 'p__x', 'c__'],
                               ['k__1', 'p__y',
                                'c__3']], [['k__1', 'p__x', 'c__1'],
                                           ['k__1', 'p__x', 'c__2']]),
               ('b', table_b, [['k__1', 'p__x', 'c__'],
                               ['k__1', 'p__y', 'c__3']], []),
               ('c', table_c, [], [])]

        obs = sample_rare_unique(t, table, tax_by_sample, 0.7)
        for o, e in zip(sorted(obs), exp):
            self.assertEqual(o[0], e[0])
            self.assertEqual(o[1], e[1])
            self.assertEqual(o[2], e[2])
            self.assertEqual(o[3], e[3])
Esempio n. 7
0
    def test_sample_rare_unique(self):
        t = update_tree(None, tax_strings_by_sample)
        tax_by_sample = {'a':tax_strings_by_sample[0],
                         'b':tax_strings_by_sample[1],
                         'c':tax_strings_by_sample[2]}
        exp = [('a', None, [['k__1','p__x','c__'],['k__1','p__y','c__3']],
                           [['k__1','p__x','c__1'],['k__1','p__x','c__2']]),
               ('b', None, [['k__1','p__x','c__'],['k__1','p__y','c__3']], []),
               ('c', None, [], [])]
        obs = sample_rare_unique(t, None, tax_by_sample, 0.7)
        self.assertEqual(sorted(obs), exp)

        table_a = Table(array([[14,15,16]]),
                               ['k__1; p__y; c__'],
                               ['a','b','c'])
        table_b = Table(array([[1,2,3],
                               [4,5,6],
                               [14,15,16]]),
                        ['k__1; p__x; c__1',
                         'k__1; p__x; c__2',
                         'k__1; p__y; c__'],
                        ['a','b','c'], )
        table_c = Table(array([[1,2,3],
                               [4,5,6],
                               [7,8,9],
                               [10,11,12],
                               [14,15,16]]),
                        ['k__1; p__x; c__1',
                         'k__1; p__x; c__2',
                         'k__1; p__x; c__',
                         'k__1; p__y; c__3',
                         'k__1; p__y; c__'],
                        ['a','b','c'])

        exp = [('a', table_a, [['k__1','p__x','c__'],['k__1','p__y','c__3']],
                           [['k__1','p__x','c__1'],['k__1','p__x','c__2']]),
               ('b', table_b, [['k__1','p__x','c__'],['k__1','p__y','c__3']], []),
               ('c', table_c, [], [])]

        obs = sample_rare_unique(t, table, tax_by_sample, 0.7)
        for o,e in zip(sorted(obs), exp):
            self.assertEqual(o[0], e[0])
            self.assertEqual(o[1], e[1])
            self.assertEqual(o[2], e[2])
            self.assertEqual(o[3], e[3])
Esempio n. 8
0
 def test_traverse(self):
     t = update_tree(None, tax_strings_by_sample)
     exp = ['c__1','c__2','p__x','c__3','p__y','k__1','root']
     obs = [n['name'] for n in traverse(t)]
     self.assertEqual(obs, exp)
 def test_traverse(self):
     t = update_tree(None, tax_strings_by_sample)
     exp = ['c__1', 'c__2', 'p__x', 'c__3', 'p__y', 'k__1', 'root']
     obs = [n['name'] for n in traverse(t)]
     self.assertEqual(obs, exp)