예제 #1
0
 def test_bad_edges(self):
     msout = """
     [1](1:0.27413282187548,2:0.27413282187548);
     [0](1:0.27413282187548,2:0.27413282187548);
     """
     with pytest.raises(tskit.TskitException):
         tsconvert.from_ms(msout)
예제 #2
0
    def test_equal_internal_node_time(self):
        #     6
        #   ┏━┻━┓
        #   4   5
        #  ┏┻┓ ┏┻┓
        #  0 1 2 3
        tables = tskit.TableCollection(1)
        for _ in range(4):
            tables.nodes.add_row(flags=tskit.NODE_IS_SAMPLE, time=0)
        tables.nodes.add_row(0, time=1)
        tables.nodes.add_row(0, time=1)
        tables.nodes.add_row(0, time=2)

        tables.edges.add_row(0, 1, 4, 0)
        tables.edges.add_row(0, 1, 4, 1)
        tables.edges.add_row(0, 1, 5, 2)
        tables.edges.add_row(0, 1, 5, 3)
        tables.edges.add_row(0, 1, 6, 4)
        tables.edges.add_row(0, 1, 6, 5)
        tables.sort()
        ts = tables.tree_sequence()
        msout = tsconvert.to_ms(ts)
        # The current algorithm assumes node times are unique
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)
예제 #3
0
    def test_n4_example(self):
        # $ mspms 4 1 -T -r 4 10 -p 8
        msout = """
        /home/jk/.local/bin/mspms 4 1 -T -r 4 10 -p 8
        961626313 1881970557 110898863

        //
        [5](1:0.70961771,(4:0.33536000,(2:0.12737966,3:0.12737966):0.20798034):0.37425772);
        [1]((2:0.12737966,3:0.12737966):0.20798034,(1:0.21249950,4:0.21249950):0.12286050);
        [2]((3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):0.20798034,1:0.33536000);
        [1](1:1.32624987,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.19887022);
        [2](1:1.80041212,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.67303246);
        """
        ts = tsconvert.from_ms(msout)
        self.assertEqual(ts.num_samples, 4)
        self.assertEqual(ts.sequence_length, 11)
        self.assertEqual(ts.num_trees, 5)

        trees = ts.trees()
        tree = next(trees)
        self.assertEqual(tree.interval, (0, 5))
        self.assertAlmostEqual(tree.branch_length(0), 0.70961771)
        self.assertAlmostEqual(tree.branch_length(1), 0.12737966)
        self.assertAlmostEqual(tree.branch_length(2), 0.12737966)
        self.assertAlmostEqual(tree.branch_length(3), 0.33536000)

        tree = next(trees)
        self.assertEqual(tree.interval, (5, 6))
        self.assertAlmostEqual(tree.branch_length(0), 0.21249950)
        self.assertAlmostEqual(tree.branch_length(1), 0.12737966)
        self.assertAlmostEqual(tree.branch_length(2), 0.12737966)
        self.assertAlmostEqual(tree.branch_length(3), 0.21249950)

        tree = next(trees)
        self.assertEqual(tree.interval, (6, 8))

        tree = next(trees)
        self.assertEqual(tree.interval, (8, 9))

        tree = next(trees)
        self.assertEqual(tree.interval, (9, 11))
        self.assertAlmostEqual(tree.branch_length(0), 1.80041212)
        self.assertAlmostEqual(tree.branch_length(1), 0.02380236)
        self.assertAlmostEqual(tree.branch_length(2), 0.12737966)
        self.assertAlmostEqual(tree.branch_length(3), 0.02380236)

        # Should get the same output if we strip off the header stuff.
        msout = """
        [5](1:0.70961771,(4:0.33536000,(2:0.12737966,3:0.12737966):0.20798034):0.37425772);
        [1]((2:0.12737966,3:0.12737966):0.20798034,(1:0.21249950,4:0.21249950):0.12286050);
        [2]((3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):0.20798034,1:0.33536000);
        [1](1:1.32624987,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.19887022);
        [2](1:1.80041212,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.67303246);
        """
        tables = tsconvert.from_ms(msout).tables
        self.assertEqual(tables, ts.tables)
예제 #4
0
    def test_n4_example(self):
        # $ mspms 4 1 -T -r 4 10 -p 8
        msout = """
        /home/jk/.local/bin/mspms 4 1 -T -r 4 10 -p 8
        961626313 1881970557 110898863
        
        //
        [5](1:0.70961771,(4:0.33536000,(2:0.12737966,3:0.12737966):0.20798034):0.37425772);
        [1]((2:0.12737966,3:0.12737966):0.20798034,(1:0.21249950,4:0.21249950):0.12286050);
        [2]((3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):0.20798034,1:0.33536000);
        [1](1:1.32624987,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.19887022);
        [2](1:1.80041212,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.67303246);
        """  # noqa: B950 W293
        ts = tsconvert.from_ms(msout)
        assert ts.num_samples == 4
        assert ts.sequence_length == 11
        assert ts.num_trees == 5

        trees = ts.trees()
        tree = next(trees)
        assert tree.interval == (0, 5)
        assert tree.branch_length(0) == pytest.approx(0.70961771)
        assert tree.branch_length(1) == pytest.approx(0.12737966)
        assert tree.branch_length(2) == pytest.approx(0.12737966)
        assert tree.branch_length(3) == pytest.approx(0.33536000)

        tree = next(trees)
        assert tree.interval == (5, 6)
        assert tree.branch_length(0) == pytest.approx(0.21249950)
        assert tree.branch_length(1) == pytest.approx(0.12737966)
        assert tree.branch_length(2) == pytest.approx(0.12737966)
        assert tree.branch_length(3) == pytest.approx(0.21249950)

        tree = next(trees)
        assert tree.interval == (6, 8)

        tree = next(trees)
        assert tree.interval == (8, 9)

        tree = next(trees)
        assert tree.interval == (9, 11)
        assert tree.branch_length(0) == pytest.approx(1.80041212)
        assert tree.branch_length(1) == pytest.approx(0.02380236)
        assert tree.branch_length(2) == pytest.approx(0.12737966)
        assert tree.branch_length(3) == pytest.approx(0.02380236)

        # Should get the same output if we strip off the header stuff.
        msout = """
        [5](1:0.70961771,(4:0.33536000,(2:0.12737966,3:0.12737966):0.20798034):0.37425772);
        [1]((2:0.12737966,3:0.12737966):0.20798034,(1:0.21249950,4:0.21249950):0.12286050);
        [2]((3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):0.20798034,1:0.33536000);
        [1](1:1.32624987,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.19887022);
        [2](1:1.80041212,(3:0.12737966,(2:0.02380236,4:0.02380236):0.10357730):1.67303246);
        """  # noqa: B950
        tables = tsconvert.from_ms(msout).tables
        tables.assert_equals(ts.tables, ignore_timestamps=True)
예제 #5
0
    def test_ms_without_recombination(self):
        msout = """
        ms 4 1 -t 5 -T -seeds 1 2 3
        1 2 3

        //
        ((2:0.0680,3:0.0680):0.1481,(1:0.2124,4:0.2124):0.0038);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)
예제 #6
0
    def test_empty_trees(self):
        msout = """
        [];
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)

        msout = """
        [1];
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)
예제 #7
0
    def test_ms_without_trees_flag(self):
        msout = """ms 3 1 -t 4 -r 5 6 -seeds 1 2 3
        1 2 3

        //
        segsites: 3
        positions: 0.3054 0.3812 0.5338
        111
        000
        100
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)
예제 #8
0
    def test_nonmatching_tips(self):
        msout = """
        [2](1:0.2144,3:0.2144);
        [4](3:0.2144,(1:0.0768,2:0.0768):0.1376);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)

        msout = """
        [2](2:0.2930,(1:0.2144,4:0.2144):0.0786);
        [4](3:0.2144,(1:0.0768,2:0.0768):0.1376);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)
예제 #9
0
 def verify(self, ts):
     msout = tsconvert.to_ms(ts.simplify())
     new_ts = tsconvert.from_ms(msout)
     self.assertEqual(ts.num_trees, new_ts.num_trees)
     for t1, t2 in zip(ts.trees(), new_ts.trees()):
         self.assertAlmostEqual(t1.interval[0], t2.interval[0])
         self.assertAlmostEqual(t1.interval[1], t2.interval[1])
         self.assertEqual(kc_distance(t1, t2), 0)
예제 #10
0
 def verify(self, ts):
     msout = tsconvert.to_ms(ts.simplify())
     new_ts = tsconvert.from_ms(msout)
     assert ts.num_trees == new_ts.num_trees
     for t1, t2 in zip(ts.trees(), new_ts.trees()):
         assert t1.interval[0] == pytest.approx(t2.interval[0])
         assert t1.interval[1] == pytest.approx(t2.interval[1])
         assert kc_distance(t1, t2) == 0
예제 #11
0
    def test_malformed_length(self):
        msout = """
        5(1:0.27413282187548,2:0.27413282187548);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)

        msout = """
        [XXX](1:0.27413282187548,2:0.27413282187548);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)

        msout = """
        [](1:0.27413282187548,2:0.27413282187548);
        """
        with pytest.raises(ValueError):
            tsconvert.from_ms(msout)

        msout = """
        [5(1:0.27413282187548,2:0.27413282187548);
        """
        with pytest.raises(dendropy.utility.error.DataParseError):
            tsconvert.from_ms(msout)
예제 #12
0
    def test_n2_example(self):
        # j$ mspms 2 1 -T -r 4 10 -p 14
        msout = """
        /home/jk/.local/bin/mspms 2 1 -T -r 4 10 -p 14
        1774173160 1383299789 1436475231

        //
        [5](1:0.27413282187548,2:0.27413282187548);
        [3](1:0.43103605328988,2:0.43103605328988);
        [1](1:1.96842212024363,2:1.96842212024363);
        [1](1:2.06027985820196,2:2.06027985820196);
        """
        ts = tsconvert.from_ms(msout)
        assert ts.num_samples == 2
        assert ts.sequence_length == 10
        assert ts.num_trees == 4

        trees = ts.trees()
        tree = next(trees)
        assert tree.interval == (0, 5)
        assert tree.branch_length(0) == pytest.approx(0.27413282187548)
        assert tree.branch_length(1) == pytest.approx(0.27413282187548)

        tree = next(trees)
        assert tree.interval == (5, 8)
        assert tree.branch_length(0) == pytest.approx(0.43103605328988)
        assert tree.branch_length(1) == pytest.approx(0.43103605328988)

        tree = next(trees)
        assert tree.interval == (8, 9)
        assert tree.branch_length(0) == pytest.approx(1.96842212024363)
        assert tree.branch_length(1) == pytest.approx(1.96842212024363)

        tree = next(trees)
        assert tree.interval == (9, 10)
        assert tree.branch_length(0) == pytest.approx(2.06027985820196)
        assert tree.branch_length(1) == pytest.approx(2.06027985820196)
예제 #13
0
    def test_n2_example(self):
        # j$ mspms 2 1 -T -r 4 10 -p 14
        msout = """
        /home/jk/.local/bin/mspms 2 1 -T -r 4 10 -p 14
        1774173160 1383299789 1436475231

        //
        [5](1:0.27413282187548,2:0.27413282187548);
        [3](1:0.43103605328988,2:0.43103605328988);
        [1](1:1.96842212024363,2:1.96842212024363);
        [1](1:2.06027985820196,2:2.06027985820196);
        """
        ts = tsconvert.from_ms(msout)
        self.assertEqual(ts.num_samples, 2)
        self.assertEqual(ts.sequence_length, 10)
        self.assertEqual(ts.num_trees, 4)

        trees = ts.trees()
        tree = next(trees)
        self.assertEqual(tree.interval, (0, 5))
        self.assertAlmostEqual(tree.branch_length(0), 0.27413282187548)
        self.assertAlmostEqual(tree.branch_length(1), 0.27413282187548)

        tree = next(trees)
        self.assertEqual(tree.interval, (5, 8))
        self.assertAlmostEqual(tree.branch_length(0), 0.43103605328988)
        self.assertAlmostEqual(tree.branch_length(1), 0.43103605328988)

        tree = next(trees)
        self.assertEqual(tree.interval, (8, 9))
        self.assertAlmostEqual(tree.branch_length(0), 1.96842212024363)
        self.assertAlmostEqual(tree.branch_length(1), 1.96842212024363)

        tree = next(trees)
        self.assertEqual(tree.interval, (9, 10))
        self.assertAlmostEqual(tree.branch_length(0), 2.06027985820196)
        self.assertAlmostEqual(tree.branch_length(1), 2.06027985820196)
예제 #14
0
    def test_full_ms_output(self):
        msout = """
        ms 3 1 -t 4 -r 5 6 -seeds 1 2 3 -T
        1 2 3

        //
        [2](2:0.2930,(1:0.2144,3:0.2144):0.0786);
        [4](3:0.2144,(1:0.0768,2:0.0768):0.1376);
        segsites: 3
        positions: 0.3054 0.3812 0.5338
        111
        000
        100
        """
        ts = tsconvert.from_ms(msout)
        assert ts.num_samples == 3
        assert ts.sequence_length == 6
        assert ts.num_trees == 2
        assert ts.num_nodes == 6

        trees = ts.trees()
        tree = next(trees)
        assert tree.interval == (0, 2)
        internal_nodes = set(tree.nodes()) - set(ts.samples())
        assert tree.branch_length(0) == pytest.approx(0.2144)
        assert tree.branch_length(1) == pytest.approx(0.2930)
        assert tree.branch_length(2) == pytest.approx(0.2144)
        assert tree.branch_length(min(internal_nodes)) == pytest.approx(0.0786)

        tree = next(trees)
        assert tree.interval == (2, 6)
        internal_nodes = set(tree.nodes()) - set(ts.samples())
        assert tree.branch_length(0) == pytest.approx(0.0768)
        assert tree.branch_length(1) == pytest.approx(0.0768)
        assert tree.branch_length(2) == pytest.approx(0.2144)
        assert tree.branch_length(min(internal_nodes)) == pytest.approx(0.1376)
예제 #15
0
 def test_single_tree(self):
     msout = """
     [1](1:0.27413282187548,2:0.27413282187548);
     """
     ts = tsconvert.from_ms(msout)
     assert ts.num_trees == 1
예제 #16
0
 def test_empty_input(self):
     with pytest.raises(ValueError):
         tsconvert.from_ms("")
예제 #17
0
 def test_zero_sequence_length(self):
     msout = """
     [0](1:0.27413282187548,2:0.27413282187548);
     """
     with pytest.raises(tskit.TskitException):
         tsconvert.from_ms(msout)
예제 #18
0
 def test_identical_node_times(self):
     msout = """
     [2](((1:1.5,2:1.5):1.7,3:3.2):1.1,(4:1.5,5:1.5):2.8);
     """
     with pytest.raises(ValueError):
         tsconvert.from_ms(msout)