示例#1
0
def tree_a():
    a = Label("a")
    a_a = Label("a_a", parent=a)

    a_a_a = Label("a_a_a", parent=a_a)

    a_a_b = Label("a_a_b", parent=a_a)
    a_a_b_a = Label("a_a_b_a", parent=a_a_b)
    a_a_b_b = Label("a_a_b_b", parent=a_a_b)

    a_a_c = Label("a_a_c", parent=a_a)
    a_a_c_a = Label("a_a_c_a")
    a_a_c_b_a = Label("a_a_c_b_a")
    a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
    a_a_c_a_a = Label("a_a_c_a_a")
    a_a_c_a_b = Label("a_a_c_a_b")
    a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

    a_a_c.add(a_a_c_a, a_a_c_b)
    a_a_c_a_a.attach(a_a_c_a)
    a_a_c_a_b.attach(a_a_c_a)

    a_b = Label("a_b", parent=a)
    a_b_a = Label("a_b_a", parent=a_b)
    a_b_a_a = Label("a_b_a_a", parent=a_b_a)
    a_b_a_b = Label("a_b_a_b", parent=a_b_a)

    return a
示例#2
0
    def test_clade(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)
        a_a_c_a = Label("a_a_c_a")
        a_a_c_b_a = Label("a_a_c_b_a")
        a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
        a_a_c_a_a = Label("a_a_c_a_a")
        a_a_c_a_b = Label("a_a_c_a_b")
        a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

        a_a_c.add(a_a_c_a, a_a_c_b)
        a_a_c_a_a.attach(a_a_c_a)
        a_a_c_a_b.attach(a_a_c_a)

        a_b = Label("a_b", parent=a)
        a_b_a = Label("a_b_a", parent=a_b)
        a_b_a_a = Label("a_b_a_a", parent=a_b_a)
        a_b_a_b = Label("a_b_a_b", parent=a_b_a)

        assert a_a_c_b.clade(a_a_c_a_b_a) == Tree(a_a_c)
        assert a_a_c_a_b_a.clade(a_a_c_b) == Tree(a_a_c)

        assert a_a_c_a_b_a.clade(a_a_b_a) == Tree(a_a)
        assert a_a_b_a.clade(a_a_c_a_b_a) == Tree(a_a)

        assert a_a.clade(a_a) == Tree(a_a)

        for label_name in a_a.descendants:
            assert a_a.clade(a_a.descendants[label_name]) == Tree(a_a)
示例#3
0
    def test_last_common_ancestor(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)
        a_a_c_a = Label("a_a_c_a")
        a_a_c_b_a = Label("a_a_c_b_a")
        a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
        a_a_c_a_a = Label("a_a_c_a_a")
        a_a_c_a_b = Label("a_a_c_a_b")
        a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

        a_a_c.add(a_a_c_a, a_a_c_b)
        a_a_c_a_a.attach(a_a_c_a)
        a_a_c_a_b.attach(a_a_c_a)

        a_b = Label("a_b", parent=a)
        a_b_a = Label("a_b_a", parent=a_b)
        a_b_a_a = Label("a_b_a_a", parent=a_b_a)
        a_b_a_b = Label("a_b_a_b", parent=a_b_a)

        assert a_a_c_b.last_common_ancestor(a_a_c_a_b_a) == a_a_c
        assert a_a_c_a_b_a.last_common_ancestor(a_a_c_b) == a_a_c

        assert a_a_c_a_b_a.last_common_ancestor(a_a_b_a) == a_a
        assert a_a_b_a.last_common_ancestor(a_a_c_a_b_a) == a_a

        assert a_a.last_common_ancestor(a_a) == a_a

        for label_name in a_a.descendants:
            assert a_a.last_common_ancestor(a_a.descendants[label_name]) == a_a
示例#4
0
    def test_attach_add_detach(self):
        label_a = Label('label_a')
        label_b = Label('label_b')
        label_c = Label('label_c', some_property='some_value')

        fake_label_a = Label('label_a')

        # Generic link testing
        label_a.attach(label_b)
        self._test_label_link(label_b, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_b, )
        assert label_b.descendants == {'label_a': label_a}

        # Not fake attach created ?
        assert label_b.parent is None
        assert not label_b.ancestors
        assert label_b.depth == 0
        assert not label_a.children
        assert not label_a.descendants

        # Assert label_c was a simple witness
        self._test_label_no_link(label_c, label_a)
        self._test_label_no_link(label_c, label_b)

        # Add another node
        label_a.add(label_c)
        self._test_label_link(label_a, label_c)

        # More exact testing here
        assert label_a.ancestors == (label_b, )
        assert label_c.ancestors == (label_a, label_b)
        assert label_a.descendants == {'label_c': label_c}
        assert label_b.descendants == {'label_a': label_a, 'label_c': label_c}

        # Not fake attach created ?
        assert label_b.parent is None
        assert not label_b.ancestors
        assert not label_c.children
        assert not label_c.descendants

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.add(label_b)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.attach(label_c)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            label_c.add(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.add(label_c)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            label_a.add(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            label_a.attach(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            fake_label_a.add(label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            fake_label_a.attach(label_a)

        # Test name collision is inefficient for add or attach
        label_b.add(fake_label_a)
        assert label_a.id in set([label.id for label in label_b.children])
        assert fake_label_a.id not in set(
            [label.id for label in label_b.children])

        label_c.attach(fake_label_a)
        assert label_c.parent.id != fake_label_a.id
        assert label_c.parent.id == label_a.id

        fake_label_a.attach(label_b)
        assert label_a.id in set([label.id for label in label_b.children])
        assert fake_label_a.id not in set(
            [label.id for label in label_b.children])

        # Remove the a -> b link upward
        label_a.detach(label_b)
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_a, label_c)

        assert label_a.parent is None
        assert not label_a.ancestors
        assert label_a.depth == 0
        assert not label_b.children
        assert not label_b.descendants

        # Remove the c -> a link downward
        label_a.detach(label_c)
        self._test_label_no_link(label_a, label_c)

        assert label_c.parent is None
        assert not label_c.ancestors
        assert label_c.depth == 0
        assert not label_a.children
        assert not label_a.descendants

        # Test silent ignore of dubious detach
        label_a.detach(label_c, label_b)

        # Test properties
        label_a.parent = label_b
        self._test_label_link(label_b, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_b, )
        assert label_b.descendants == {'label_a': label_a}

        # Test properties
        label_a.parent = label_c
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_c, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_c, )
        assert label_c.descendants == {'label_a': label_a}

        label_c.detach(label_a)
        # Test properties
        label_a.children = (label_b, )
        self._test_label_link(label_a, label_b)

        # More exact testing here
        assert label_b.depth == 1
        assert label_b.ancestors == (label_a, )
        assert label_a.descendants == {'label_b': label_b}

        # Test properties
        label_a.children = (label_c, )
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_a, label_c)

        # More exact testing here
        assert label_c.depth == 1
        assert label_c.ancestors == (label_a, )
        assert label_a.descendants == {'label_c': label_c}

        # Test constructor
        label_d = Label('label_d', parent=label_a)
        self._test_label_link(label_a, label_c)
        self._test_label_link(label_a, label_d)

        # More exact testing here
        assert label_d.depth == 1
        assert label_d.ancestors == (label_a, )
        assert label_a.descendants == {'label_c': label_c, 'label_d': label_d}

        label_e = Label('label_e', children=(label_a, label_b))
        self._test_label_link(label_e, label_b)
        self._test_label_link(label_e, label_a)
        self._test_label_link(label_a, label_c)
        self._test_label_link(label_a, label_d)

        # More exact testing here
        assert label_b.depth == 1
        assert label_b.ancestors == (label_e, )
        assert label_d.depth == 2
        assert label_d.ancestors == (label_a, label_e)
        assert label_e.descendants == {
            'label_a': label_a,
            'label_b': label_b,
            'label_c': label_c,
            'label_d': label_d
        }