#! /usr/bin/env python ############################################################################## ## DendroPy Phylogenetic Computing Library. ## ## Copyright 2010-2015 Jeet Sukumaran and Mark T. Holder. ## All rights reserved. ## ## See "LICENSE.rst" for terms and conditions of usage. ## ## If you use this work or any portion thereof in published work, ## please cite it as: ## ## Sukumaran, J. and M. T. Holder. 2010. DendroPy: a Python library ## for phylogenetic computing. Bioinformatics 26: 1569-1571. ## ############################################################################## """ Tests for general NEWICK reading. """ import sys import os import unittest import itertools import collections import random import dendropy from dendropy.utility import error from dendropy.dataio import newickreader from dendropy.test.support import dendropytest from dendropy.test.support import compare_and_validate from dendropy.test.support import standard_file_test_trees from dendropy.test.support import curated_test_tree from dendropy.test.support import pathmap from dendropy.utility.messaging import get_logger _LOG = get_logger(__name__) if sys.hexversion < 0x03040000: from dendropy.utility.filesys import pre_py34_open as open class NewickTreeReaderBasic( curated_test_tree.CuratedTestTree, dendropytest.ExtendedTestCase): def test_basic_parsing(self): tree_string = self.get_newick_string() reader_kwargs = {} with pathmap.SandboxedFile() as tempf: tempf.write(tree_string) tempf.flush() tree_filepath = tempf.name for suppress_internal_node_taxa in (None, False, True): if suppress_internal_node_taxa is None: expected_suppress_internal_node_taxa = True reader_kwargs.pop("suppress_internal_node_taxa", None) else: expected_suppress_internal_node_taxa = suppress_internal_node_taxa reader_kwargs["suppress_internal_node_taxa"] = suppress_internal_node_taxa for suppress_leaf_node_taxa in (None, False, True): if suppress_leaf_node_taxa is None: expected_suppress_leaf_node_taxa = False reader_kwargs.pop("suppress_leaf_node_taxa", None) else: expected_suppress_leaf_node_taxa = suppress_leaf_node_taxa reader_kwargs["suppress_leaf_node_taxa"] = suppress_leaf_node_taxa for suppress_edge_lengths in (None, False, True): if suppress_edge_lengths is None: expected_suppress_edge_lengths = False reader_kwargs.pop("suppress_edge_lengths", None) else: expected_suppress_edge_lengths = suppress_edge_lengths reader_kwargs["suppress_edge_lengths"] = suppress_edge_lengths with open(tree_filepath, "r") as tree_stream: approaches = ( {"path": tree_filepath}, {"file": tree_stream}, {"data": tree_string}, ) for approach_kwargs in approaches: approach_kwargs.update(reader_kwargs) approach_kwargs["schema"] = "newick" t = dendropy.Tree.get(**approach_kwargs) self.verify_curated_tree(t, suppress_internal_node_taxa=expected_suppress_internal_node_taxa, suppress_leaf_node_taxa=expected_suppress_leaf_node_taxa, suppress_edge_lengths=expected_suppress_edge_lengths) # approaches = ( # (dendropy.Tree.get_from_path, tree_filepath), # (dendropy.Tree.get_from_stream, tree_stream), # (dendropy.Tree.get_from_string, tree_string), # ) # for method, src in approaches: # t = method(src, # "newick", # **reader_kwargs # ) # self.verify_curated_tree(t, # suppress_internal_node_taxa=expected_suppress_internal_node_taxa, # suppress_leaf_node_taxa=expected_suppress_leaf_node_taxa, # suppress_edge_lengths=expected_suppress_edge_lengths) # with open(tree_filepath, "r") as tree_stream: # approaches = ( # ("read_from_path", tree_filepath), # ("read_from_stream", tree_stream), # ("read_from_string", tree_string), # ) # for method, src in approaches: # t = dendropy.Tree.get_from_string("(zzz1,(zzz2,(zzz3,zzz4)));", # "newick", # suppress_internal_node_taxa=False, # suppress_leaf_node_taxa=False,) # tns0 = t.taxon_namespace # self.assertIs(t.taxon_namespace, tns0) # f = getattr(t, method) # self.assertIs(t.taxon_namespace, tns0) # f(src, "newick", **reader_kwargs) # self.verify_curated_tree(t, # suppress_internal_node_taxa=expected_suppress_internal_node_taxa, # suppress_leaf_node_taxa=expected_suppress_leaf_node_taxa, # suppress_edge_lengths=expected_suppress_edge_lengths) def test_rooting_weighting_and_tree_metadata_handling(self): rooting_tokens = ("", "[&R]", "[&U]", "[&r]", "[&u]", "[&0]", "[&invalid]", "[R]", "[U]", "[&]") rooting_interpretations = ("force-rooted", "force-unrooted", "default-rooted", "default-unrooted", None) for rooting_token in rooting_tokens: for rooting_interpretation in rooting_interpretations: if rooting_interpretation == "force-rooted": expected_is_rooted = True expected_is_unrooted = False expected_is_rootedness_undefined = False elif rooting_interpretation == "force-unrooted": expected_is_rooted = False expected_is_unrooted = True expected_is_rootedness_undefined = False elif rooting_interpretation == "default-rooted": if rooting_token.upper() == "[&R]": expected_is_rooted = True expected_is_unrooted = False expected_is_rootedness_undefined = False elif rooting_token.upper() == "[&U]": expected_is_rooted = False expected_is_unrooted = True expected_is_rootedness_undefined = False else: expected_is_rooted = True expected_is_unrooted = False expected_is_rootedness_undefined = False elif rooting_interpretation == "default-unrooted": if rooting_token.upper() == "[&R]": expected_is_rooted = True expected_is_unrooted = False expected_is_rootedness_undefined = False elif rooting_token.upper() == "[&U]": expected_is_rooted = False expected_is_unrooted = True expected_is_rootedness_undefined = False else: expected_is_rooted = False expected_is_unrooted = True expected_is_rootedness_undefined = False elif rooting_interpretation is None: if rooting_token.upper() == "[&R]": expected_is_rooted = True expected_is_unrooted = False expected_is_rootedness_undefined = False elif rooting_token.upper() == "[&U]": expected_is_rooted = False expected_is_unrooted = True expected_is_rootedness_undefined = False else: expected_is_rooted = None expected_is_unrooted = None expected_is_rootedness_undefined = True else: raise Exception("Unexpected rooting interpretation: '{}'".format(rooting_interpretation)) weighting_tokens = ("", "[&w 0.25]", "[ &W 0.25]", "[&w 1/4]", "[&W 1/4]") for weighting_token in weighting_tokens: for store_tree_weights in (False, True): for extract_comment_metadata in (False, True): # pre_tree_token_candidates = ["[&color=blue]", weighting_token, rooting_token] # for token_combination in itertools.permutations(pre_tree_token_candidates): token_combination = ["[&color=blue]", "[&Why=42]", weighting_token, "[&rate=0.15]", rooting_token, "[&lnL=-3.14]"] token_str = "".join(token_combination) _LOG.debug("Token = '{}', Rooting interpretation = '{}'".format(token_str, rooting_interpretation)) s = self.get_newick_string(tree_preamble_tokens=token_str) _LOG.debug(s) t = dendropy.Tree.get( data=s, schema="newick", rooting=rooting_interpretation, store_tree_weights=store_tree_weights, extract_comment_metadata=extract_comment_metadata) self.assertIs(t.is_rooted, expected_is_rooted) self.assertIs(t.is_unrooted, expected_is_unrooted) self.assertIs(t.is_rootedness_undefined, expected_is_rootedness_undefined) if store_tree_weights: if weighting_token: self.assertEqual(t.weight, 0.25) else: self.assertEqual(t.weight, 1.0) else: self.assertIs(t.weight, None) if extract_comment_metadata: self.assertEqual(t.annotations.get_value("color", None), "blue") self.assertEqual(t.annotations.get_value("Why", None), "42") class NewickTreeMultifurcatingtree(dendropytest.ExtendedTestCase): def test_multifurcating(self): s = """\ ([p]([a]a:1[a],[b]b:2[b],[c]c:3[c],[s]([d]d:4[d], [e]e:5[e],[f]f:6[f],[g]g:7[g])[s]s:19[s])[p]p:16[p],[w] ([t]t:20[t],[u]u:21[u],[v]v:22[v])[w]w:23[w],[q] ([h]h:8[h],[i]i:9[i],[j]j:10[j],[k]k:11[k],[o]([l]l:12[l],[m]m:13[m],[n]n:14[n])[o]o:15[o])[q]q:17[q])[r]r:18[r][r]; """ tree = dendropy.Tree.get(data=s, schema="newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True) expected_children = { 'a': [], 'b': [], 'c': [], 'd': [], 'e': [], 'f': [], 'g': [], 'h': [], 'i': [], 'j': [], 'k': [], 'l': [], 'm': [], 'n': [], 'o': ['l','m','n'], 'p': ['s', 'a', 'b', 'c'], 'q': ['o', 'h', 'i', 'j','k'], 'r': ['q','p', 'w'], 's': ['d', 'e', 'f', 'g'], 't': [], 'u': [], 'v': [], 'w': ['t', 'u', 'v'], } expected_parent = { 'a': 'p', 'b': 'p', 'c': 'p', 'd': 's', 'e': 's', 'f': 's', 'g': 's', 'h': 'q', 'i': 'q', 'j': 'q', 'k': 'q', 'l': 'o', 'm': 'o', 'n': 'o', 'o': 'q', 'p': 'r', 'q': 'r', 'r': None, 's': 'p', 't': 'w', 'u': 'w', 'v': 'w', 'w': 'r', } for nd in tree: children = [ch.label for ch in nd.child_node_iter()] self.assertCountEqual(children, expected_children[nd.label]) if nd.parent_node is not None: self.assertEqual(nd.parent_node.label, expected_parent[nd.label]) else: self.assertIs(expected_parent[nd.label], None) if nd.is_leaf(): self.assertEqual(len(nd.comments), 2) else: self.assertEqual(len(nd.comments), 3) for comment in nd.comments: self.assertEqual(comment, nd.label) self.assertEqual(nd.edge.length, ord(nd.label) - ord('a') + 1) class NewickTreeInvalidStatements(dendropytest.ExtendedTestCase): def test_invalid_trees(self): invalid_tree_statements = ( "(a,(b,c))a", "(a,(b,c)) (b,(a,c))", "(a,(b,c)) (d,(e,f))", "(a,(b,c)),", "(a,(b,c)z1)z2,", "(a,(b,c)))", "(a,(b,c)):", "(a,(b,c))(", "(e,(c,(d,e)a)b;(b,(a,e)c)d;", ) for s in invalid_tree_statements: # t = dendropy.Tree.get_from_string(s, "newick") with self.assertRaises(error.DataParseError): t = dendropy.Tree.get(data=s, schema="newick") class NewickTreeDuplicateTaxa( curated_test_tree.CuratedTestTree, dendropytest.ExtendedTestCase): def test_duplicate_taxa1(self): tree_statements = ( "((a,b)c,(b,c)a)d;", "((_,_)_,(_,_)_)_;", ) expected_labels = ( ("a","b","c","b","c","a","d"), (" "," "," "," "," "," "," "), ) for sidx, s in enumerate(tree_statements): with self.assertRaises(newickreader.NewickReader.NewickReaderDuplicateTaxonError): tree = dendropy.Tree.get(data=s, schema="newick") tree = dendropy.Tree.get(data=s, schema="newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True) labels = [nd.label for nd in tree] self.assertCountEqual(labels, expected_labels[sidx]) class NewickTreeAnonymousTaxa(dendropytest.ExtendedTestCase): def test_anonymous_taxa_no_error(self): s = "((,),(,(,(,))));" tree = dendropy.Tree.get(data=s, schema="newick") def test_anonymous_taxa(self): s = "((:1[a],:2[b])[c]:3,(:4[d],([e]:5,([f]:6,:7[g]):8[h])[i]:9)[j]:10):11[k];" tree = dendropy.Tree.get( data=s, schema="newick") self.assertEqual(len(tree.taxon_namespace), 0) anodes = [nd for nd in tree] leaves = [nd for nd in tree.leaf_node_iter()] internal = [nd for nd in tree.postorder_internal_node_iter()] self.assertEqual(len(anodes), 11) self.assertEqual(len(leaves), 6) self.assertEqual(len(internal), 5) leaf_labels = [nd.comments[0] for nd in leaves] internal_labels = [nd.comments[0] for nd in internal] self.assertCountEqual(leaf_labels, ('a','b','d','e','f','g')) self.assertCountEqual(internal_labels, ('c','h','i','j','k')) for nd in tree: x = nd.comments[0] k = ord(x) - ord('a') + 1 self.assertEqual(nd.edge.length, k) class NewickTreeUnsupportedKeywordArguments( curated_test_tree.CuratedTestTree, dendropytest.ExtendedTestCase): def test_unsupported_keyword_arguments(self): tree_filepath = pathmap.tree_source_path('dendropy-test-trees-n12-x2.newick') tree_string = self.get_newick_string() reader_kwargs = { "suppress_internal_taxa": True, # should be suppress_internal_node_taxa "gobbledegook": False, } with open(tree_filepath, "r") as tree_stream: approaches = ( (dendropy.Tree.get_from_path, tree_filepath), (dendropy.Tree.get_from_stream, tree_stream), (dendropy.Tree.get_from_string, tree_string), ) for method, src in approaches: with self.assertRaises(TypeError): t = method(src, "newick", **reader_kwargs) # with open(tree_filepath, "r") as tree_stream: # approaches = ( # ("read_from_path", tree_filepath), # ("read_from_stream", tree_stream), # ("read_from_string", tree_string), # ) # for method, src in approaches: # t = dendropy.Tree() # tns0 = t.taxon_namespace # self.assertIs(t.taxon_namespace, tns0) # f = getattr(t, method) # self.assertIs(t.taxon_namespace, tns0) # with self.assertRaises(TypeError): # f(src, "newick", **reader_kwargs) class NewickTreeQuotedLabels(dendropytest.ExtendedTestCase): def test_edge_lengths1(self): tree = dendropy.Tree.get_from_string( """ ((('T1 = 1.242e-10':1.242e-10, 'T2 is 213.31e-4':213.31e-4)i1:3.44e-3, ('T3 is a (nice) taxon':3.3e7, T4:4.4e+8)'this is an internal node called "i2"':4.0e+1)i3:4.0E-4, (T5:6.7E+2, 'and this so-called ''node'' is ("T6" with a length of ''7.2E-9'')':7.2E-9)i4:4.0E8)'this is the ''root\'\'\':7.0; """, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, ) expected_edge_lens = { 'T1 = 1.242e-10': 1.242e-10, 'T2 is 213.31e-4': 213.31e-4, 'i1': 3.44e-3, 'T3 is a (nice) taxon': 3.3e7, 'T4': 4.4e+8, 'this is an internal node called "i2"': 4.0e+1, 'i3': 4.0e-4, 'T5': 6.7e+2, "and this so-called 'node' is (\"T6\" with a length of '7.2E-9')": 7.2e-9, 'i4': 4.0e8, "this is the 'root'": 7.0, } for nd in tree.postorder_node_iter(): self.assertAlmostEqual(nd.edge.length, expected_edge_lens[nd.label]) class CommentReadingTests(dendropytest.ExtendedTestCase): def test_simple_post_node_comments(self): s = "((A[A]:1,B[B]:1)AB[AB]:1,(C[C]:1,D[D]:1)CD[CD]:1)Root[Root]:1;" _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, ) for nd in tree: _LOG.info("%s: %s" % (nd.label, nd.comments)) self.assertEqual(len(nd.comments), 1) self.assertEqual(nd.comments[0], nd.label) self.assertEqual(nd.edge.length, 1) def test_simple_post_edge_length_comments(self): s = "((A:1[A],B:1[B])AB:1[AB],(C:1[C],D:1[D])CD:1[CD])Root:1[Root];" _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, ) for nd in tree: _LOG.info("%s: %s" % (nd.label, nd.comments)) self.assertEqual(len(nd.comments), 1) self.assertEqual(nd.comments[0], nd.label) def test_post_node_and_edge_comments(self): s = "((A[A]:1[A],B[B]:1[B])AB[AB]:1[AB],(C[C]:1[C],D[D]:1[D])CD[CD]:1[CD])Root[Root]:1[Root];" _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, ) for nd in tree: _LOG.info("%s: %s" % (nd.label, nd.comments)) self.assertEqual(len(nd.comments), 2) self.assertEqual(nd.comments[0], nd.label) self.assertEqual(nd.comments[1], nd.label) def test_multi_position_comments(self): s = """(([xxx]A[A][A]:[A][A]1[A][A], [xxx]B[B][B]:[B][B]1[B][B]) [xxx]AB[AB][AB]:[AB][AB]1[AB][AB], ([xxx]C[C][C]:[C][C]1[C][C], [xxx]D[D][D]:[D][D]1[D][D]) [xxx]CD[CD][CD]:[CD][CD]1[CD][CD]) [xxx]Root[Root][Root]:[Root][Root]1[Root][Root];""" _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, ) for nd in tree: _LOG.info("%s: %s" % (nd.label, nd.comments)) self.assertEqual(len(nd.comments), 7) self.assertEqual(nd.comments[0], 'xxx') for i in range(1,7): self.assertEqual(nd.comments[i], nd.label) def test_comment_association(self): tree_strings = [ "([a1][a2]a[a3]:[a4]1[a5],[h1][h2][h3]([b1]b[b2]:[b3][b4]2[b5],[g1][g2]([c1]c[c2]:[c3]3[c4][c5],[f1]([d1]d[d2][d3]:[d4]4[d5],[e1]e[e2]:5[e3][e4][e5])[f2]f[f3]:[f4]6[f5])[g3][g4]g:7[g5])[h4]h[h5]:8)[i1][i2]i[i3]:[i4]9[i5];", ] for tree_string in tree_strings: tree = dendropy.Tree.get_from_string( tree_string, "newick", suppress_leaf_node_taxa=True) for nd in tree: exp_brlen = ord(nd.label[0]) - ord('a') + 1 self.assertEqual(nd.edge.length, exp_brlen) self.assertEqual(len(nd.comments), 5) for comment in nd.comments: self.assertEqual(comment[0], nd.label) def test_anonymous_node_comment_association(self): tree_string1 = "[x1]([x2],[x3]([x4],[x5]([x6],[x7],[x8],[x9])[x10])[x11])[x12];" tree_string2 = "[x1](a[x2],[x3]([x4]b,[x5]([x6]c,[x7]d,[x8]e,[x9]f)g[x10])h[x11])i[x12];" tree1 = dendropy.Tree.get_from_string(tree_string1, "newick", suppress_leaf_node_taxa=True) tree2 = dendropy.Tree.get_from_string(tree_string2, "newick", suppress_leaf_node_taxa=True) expected_comments = { "a": ["x2",], "b": ["x4",], "c": ["x6",], "d": ["x7",], "e": ["x8",], "f": ["x9",], "g": ["x5", "x10"], "h": ["x3", "x11"], "i": ["x12"], } nodes1 = [nd for nd in tree1] nodes2 = [nd for nd in tree2] for nd1, nd2 in zip(nodes1, nodes2): self.assertEqual(nd2.comments, expected_comments[nd2.label]) self.assertEqual(nd1.comments, expected_comments[nd2.label]) class CommentMetaDataTests(dendropytest.ExtendedTestCase): figtree_metadata_str = """[&Tree1=1,Tree2=2, Tree3={1,2,3}](([xxx]A[&A1=1,A2=2,A3={1,2,3}, ,][A]:[A][A]1[A][A], [xxx]B[&B1=1,B2=2,B3={1,2,3}][B]:[B][B]1[B][B]) [xxx]AB[&AB1=1,AB2=2,AB3={1,2,3}][AB]:[AB][AB]1[AB][AB], ([xxx]C[&C1=1,C2=2,C3={1,2,3}][C]:[C][C]1[C][C], [xxx]D[&D1=1,D2=2,D3={1,2,3}][D]:[D][D]1[D][D]) [xxx]CD[&CD1=1, CD2=2, CD3={1,2,3}][CD]:[CD][CD]1[CD][CD]) [xxx]Root[&Root1=1, Root2=2, Root3={1,2,3}][Root]:[Root][Root]1[Root][Root];""" nhx_metadata_str = """[&Tree1=1,Tree2=2, Tree3={1,2,3}](([xxx]A[&&A1=1:A2=2:A3={1,2,3}][A]:[A][A]1[A][A], [xxx]B[&&B1=1:B2=2:B3={1,2,3}][B]:[B][B]1[B][B]) [xxx]AB[&&AB1=1:AB2=2:AB3={1,2,3}][AB]:[AB][AB]1[AB][AB], ([xxx]C[&&C1=1:C2=2:C3={1,2,3}][C]:[C][C]1[C][C], [xxx]D[&&D1=1:D2=2:D3={1,2,3}][D]:[D][D]1[D][D]) [xxx]CD[&&CD1=1: CD2=2: CD3={1,2,3}][CD]:[CD][CD]1[CD][CD]) [xxx]Root[&&Root1=1: Root2=2: Root3={1,2,3}][Root]:[Root][Root]1[Root][Root];""" def check_results(self, tree): metadata = tree.annotations.values_as_dict() self.assertEqual(metadata, {'Tree1': '1', 'Tree2': '2', 'Tree3':['1','2','3']}) for nd in tree.postorder_node_iter(): metadata = nd.annotations.values_as_dict() #print("%s: %s => %s" % (nd.label, nd.comments, metadata)) self.assertEqual(len(metadata), 3) values = ["1", "2", ["1","2","3"]] for i in range(3): key = "{}{}".format(nd.label, i+1) self.assertTrue(key in metadata) self.assertEqual(metadata[key], values[i]) def testFigtreeStyleBasic(self): s = self.figtree_metadata_str _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, extract_comment_metadata=True) self.check_results(tree) def testNHXBasic(self): s = self.nhx_metadata_str _LOG.info("Tree = %s" % s) tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, extract_comment_metadata=True) self.check_results(tree) def test_incomplete_metadata(self): s = """[&color=blue](A[®ion=Asia,id=00012][cryptic],(B[®ion=Africa],C[®ion=Madagascar,id=19391][two of three]));""" tree = dendropy.Tree.get_from_string( s, "newick", suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True, extract_comment_metadata=True, ) self.assertEqual(tree.annotations.values_as_dict(), {'color': 'blue'}) expected = [ {'region': 'Asia', 'id': '00012'}, {'region': 'Africa'}, {'region': 'Madagascar', 'id': '19391'}, {}, {},] for idx, nd in enumerate(tree.postorder_node_iter()): self.assertEqual(nd.annotations.values_as_dict(), expected[idx]) # class NewickTreeTaxonNamespaceTest(dendropytest.ExtendedTestCase): # def test_namespace_passing(self): # tns1 = dendropy.TaxonNamespace() # s1 = "(a,(b,c));" # tree = dendropy.Tree.get_from_string( # s1, "newick", taxon_namespace=tns1) # self.assertIs(tree.taxon_namespace, tns1) # self.assertEqual(len(tns1), 3) # s2 = "((e,f),(g,h));" # tree.read_from_string( # s2, "newick") # self.assertIs(tree.taxon_namespace, tns1) # self.assertEqual(len(tns1), 7) # tns2 = dendropy.TaxonNamespace() # s3 = "((j,k),(l,m));" # with self.assertRaises(TypeError): # tree.read_from_string( # s3, "newick", # taxon_namespace=tns2) class NewickTreeLabelParsingTest(dendropytest.ExtendedTestCase): def test_basic_taxa(self): s = "(a1:3.14e-2,(b2:1.2,(c3:0.5,d4:0.7)e5:111)f6:222)g7:333;" tree = dendropy.Tree.get_from_string(s, "newick", suppress_internal_node_taxa=False) expected = { "a1": 3.14e-2, "b2": 1.2, "c3": 0.5, "d4": 0.7, "e5": 111, "f6": 222, "g7": 333, } tns = tree.taxon_namespace self.assertEqual(len(tns), len(expected)) labels = set([t.label for t in tns]) self.assertEqual(labels, set(expected.keys())) for nd in tree: self.assertEqual(nd.edge.length, expected[nd.taxon.label]) def test_quoted_underscores(self): s = "('a_1':3.14e-2,('b_2':1.2,('c_3':0.5,'d_4':0.7)'e_5':111)'f_6':222)'g_7':333;" tree = dendropy.Tree.get_from_string(s, "newick", suppress_internal_node_taxa=False) expected = { "a_1": 3.14e-2, "b_2": 1.2, "c_3": 0.5, "d_4": 0.7, "e_5": 111, "f_6": 222, "g_7": 333, } tns = tree.taxon_namespace self.assertEqual(len(tns), len(expected)) labels = set([t.label for t in tns]) self.assertEqual(labels, set(expected.keys())) for nd in tree: self.assertEqual(nd.edge.length, expected[nd.taxon.label]) def test_unquoted_underscores(self): s = "(a_1:3.14e-2,(b_2:1.2,(c_3:0.5,d_4:0.7)e_5:111)f_6:222)g_7:333;" tree = dendropy.Tree.get_from_string(s, "newick", suppress_internal_node_taxa=False) expected = { "a 1": 3.14e-2, "b 2": 1.2, "c 3": 0.5, "d 4": 0.7, "e 5": 111, "f 6": 222, "g 7": 333, } tns = tree.taxon_namespace self.assertEqual(len(tns), len(expected)) labels = set([t.label for t in tns]) self.assertEqual(labels, set(expected.keys())) for nd in tree: self.assertEqual(nd.edge.length, expected[nd.taxon.label]) def test_unquoted_underscores_preserved(self): s = "(a_1:3.14e-2,(b_2:1.2,(c_3:0.5,d_4:0.7)e_5:111)f_6:222)g_7:333;" tree = dendropy.Tree.get_from_string(s, "newick", suppress_internal_node_taxa=False, preserve_underscores=True) expected = { "a_1": 3.14e-2, "b_2": 1.2, "c_3": 0.5, "d_4": 0.7, "e_5": 111, "f_6": 222, "g_7": 333, } tns = tree.taxon_namespace self.assertEqual(len(tns), len(expected)) labels = set([t.label for t in tns]) self.assertEqual(labels, set(expected.keys())) for nd in tree: self.assertEqual(nd.edge.length, expected[nd.taxon.label]) class NewickTreeReaderOffsetTreeTest( standard_file_test_trees.NewickTestTreesChecker, dendropytest.ExtendedTestCase): @classmethod def setUpClass(cls): standard_file_test_trees.NewickTestTreesChecker.create_class_fixtures(cls) def test_tree_offset_newick_get(self): tree_file_title = "dendropy-test-trees-n33-unrooted-x100a" tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] expected_number_of_trees = tree_reference["num_trees"] tree_offsets = set([0, expected_number_of_trees-1, -1, -expected_number_of_trees]) while len(tree_offsets) < 8: tree_offsets.add(random.randint(1, expected_number_of_trees-2)) while len(tree_offsets) < 12: tree_offsets.add(random.randint(-expected_number_of_trees-2, -2)) tree_filepath = self.schema_tree_filepaths[tree_file_title] with open(tree_filepath, "r") as src: tree_string = src.read() for tree_offset in tree_offsets: tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] expected_number_of_trees = tree_reference["num_trees"] if tree_offset < 0: if abs(tree_offset) > expected_number_of_trees: tree_offset = 0 else: tree_offset = expected_number_of_trees + tree_offset with open(tree_filepath, "r") as tree_stream: approaches = ( (dendropy.Tree.get_from_path, tree_filepath), (dendropy.Tree.get_from_stream, tree_stream), (dendropy.Tree.get_from_string, tree_string), ) for method, src in approaches: tree = method( src, "newick", collection_offset=0, tree_offset=tree_offset, suppress_internal_node_taxa=True, suppress_leaf_node_taxa=False, rooting="default-unrooted") reference_tree_idx = tree_offset self.compare_to_reference_by_title_and_index( tree=tree, tree_file_title=tree_file_title, reference_tree_idx=tree_offset) def test_offset_get_with_redundant_semicolons(self): s = """\ ;;;;(a,(b,c)d)e;;;;(e,(c,a)d)b;;;;(b,(a,e)c)d;;;; """ expected_roots = { 0 : 'e', 1 : 'b', 2 : 'd', } expected_leaves = { 0 : ['a', 'b', 'c'], 1 : ['e', 'c', 'a'], 2 : ['b', 'a', 'e'], } for idx in range(3): tree = dendropy.Tree.get_from_string( s, "newick", collection_offset=0, tree_offset=idx, suppress_internal_node_taxa=True, suppress_leaf_node_taxa=True) self.assertEqual(tree.seed_node.label, expected_roots[idx]) leaves = [nd.label for nd in tree.leaf_node_iter()] self.assertCountEqual(leaves, expected_leaves[idx]) # def test_tree_offset_newick_read(self): # tree_file_title = "dendropy-test-trees-n33-unrooted-x100a" # tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] # expected_number_of_trees = tree_reference["num_trees"] # tree_offsets = set([0, expected_number_of_trees-1, -1, -expected_number_of_trees]) # while len(tree_offsets) < 8: # tree_offsets.add(random.randint(1, expected_number_of_trees-2)) # while len(tree_offsets) < 12: # tree_offsets.add(random.randint(-expected_number_of_trees-2, -2)) # tree_filepath = self.schema_tree_filepaths[tree_file_title] # with open(tree_filepath, "r") as src: # tree_string = src.read() # for tree_offset in tree_offsets: # tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] # expected_number_of_trees = tree_reference["num_trees"] # if tree_offset < 0: # if abs(tree_offset) > expected_number_of_trees: # tree_offset = 0 # else: # tree_offset = expected_number_of_trees + tree_offset # with open(tree_filepath, "r") as tree_stream: # approaches = ( # ("read_from_path", tree_filepath), # ("read_from_stream", tree_stream), # ("read_from_string", tree_string), # ) # for method, src in approaches: # tree = dendropy.Tree() # tns0 = tree.taxon_namespace # f = getattr(tree, method) # trees_read = f(src, # "newick", # collection_offset=0, # tree_offset=tree_offset, # suppress_internal_node_taxa=True, # suppress_leaf_node_taxa=False, # rooting="default-unrooted") # self.assertIs(tree.taxon_namespace, tns0) # reference_tree_idx = tree_offset # self.compare_to_reference_by_title_and_index( # tree=tree, # tree_file_title=tree_file_title, # reference_tree_idx=tree_offset) def test_tree_offset_without_collection_offset_newick_get(self): tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' tree_filepath = self.schema_tree_filepaths[tree_file_title] tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] expected_number_of_trees = tree_reference["num_trees"] with open(tree_filepath, "r") as src: tree_string = src.read() with open(tree_filepath, "r") as tree_stream: approaches = ( (dendropy.Tree.get_from_path, tree_filepath), (dendropy.Tree.get_from_stream, tree_stream), (dendropy.Tree.get_from_string, tree_string), ) for approach in approaches: tree_offset = 2 tree = approach[0](approach[1], "newick", tree_offset=tree_offset) reference_tree_idx = tree_offset self.compare_to_reference_by_title_and_index( tree=tree, tree_file_title=tree_file_title, reference_tree_idx=tree_offset) # def test_tree_offset_without_collection_offset_newick_read(self): # tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' # tree_filepath = self.schema_tree_filepaths[tree_file_title] # approaches = ( # "read_from_path", # "read_from_stream", # "read_from_string", # ) # for approach in approaches: # tree = dendropy.Tree() # f = getattr(tree, approach) # with self.assertRaises(TypeError): # f(tree_filepath, "newick", collection_offset=None, tree_offset=0) def test_out_of_range_tree_offset_newick_get(self): tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' tree_filepath = self.schema_tree_filepaths[tree_file_title] tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] expected_number_of_trees = tree_reference["num_trees"] with open(tree_filepath, "r") as src: tree_string = src.read() with open(tree_filepath, "r") as tree_stream: approaches = ( (dendropy.Tree.get_from_path, tree_filepath), (dendropy.Tree.get_from_stream, tree_stream), (dendropy.Tree.get_from_string, tree_string), ) for method, src in approaches: with self.assertRaises(IndexError): method(src, "newick", collection_offset=0, tree_offset=expected_number_of_trees) # def test_out_of_range_tree_offset_newick_read(self): # tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' # tree_filepath = self.schema_tree_filepaths[tree_file_title] # tree_reference = standard_file_test_trees._TREE_REFERENCES[tree_file_title] # expected_number_of_trees = tree_reference["num_trees"] # with open(tree_filepath, "r") as src: # tree_string = src.read() # with open(tree_filepath, "r") as tree_stream: # approaches = ( # ("read_from_path", tree_filepath), # ("read_from_stream", tree_stream), # ("read_from_string", tree_string), # ) # for method, src in approaches: # tree = dendropy.Tree() # f = getattr(tree, method) # with self.assertRaises(IndexError): # f(src, "newick", collection_offset=0, tree_offset=expected_number_of_trees) def test_out_of_range_collection_offset_newick_get(self): tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' tree_filepath = self.schema_tree_filepaths[tree_file_title] with open(tree_filepath, "r") as src: tree_string = src.read() with open(tree_filepath, "r") as tree_stream: approaches = ( (dendropy.Tree.get_from_path, tree_filepath), (dendropy.Tree.get_from_stream, tree_stream), (dendropy.Tree.get_from_string, tree_string), ) for method, src in approaches: with self.assertRaises(IndexError): method(src, "newick", collection_offset=1, tree_offset=0) # def test_out_of_range_collection_offset_newick_read(self): # tree_file_title = 'dendropy-test-trees-n33-unrooted-x10a' # tree_filepath = self.schema_tree_filepaths[tree_file_title] # with open(tree_filepath, "r") as src: # tree_string = src.read() # with open(tree_filepath, "r") as tree_stream: # approaches = ( # ("read_from_path", tree_filepath), # ("read_from_stream", tree_stream), # ("read_from_string", tree_string), # ) # for method, src in approaches: # tree = dendropy.Tree() # f = getattr(tree, method) # with self.assertRaises(IndexError): # f(src, "newick", collection_offset=1, tree_offset=0) class JplaceParsingTest(dendropytest.ExtendedTestCase): def test_basic(self): s = "((A:.01[e]{0}, B:.02{1})D:.3{3}[g], C:.04{4}[h]) {5};" tree = dendropy.Tree.get_from_string(s, "newick", is_parse_jplace_tokens=True) self.assertEqual([0.01, 0.02, 0.3, 0.04, None], [e.length for e in tree.edge_index]) self.assertEqual('((A:0.01,B:0.02)D:0.3,C:0.04)', str(tree)) self.assertEqual([0,1,3,4,5], [e.edge_number for e in tree.edge_index]) def test_do_not_parse_by_default(self): s = "((A:.01[e]{0}, B:.02{1})D:.3{3}[g], C:.04{4}[h]) {5};" with self.assertRaises(newickreader.NewickReader.NewickReaderMalformedStatementError): try: tree = dendropy.Tree.get_from_string(s, "newick") except newickreader.NewickReader.NewickReaderMalformedStatementError as e: self.assertEqual( "Expecting ':', ')', ',' or ';' after reading label but found '{'", e.message) raise e def test_malformed_error_message_parsing_jplace(self): s = "((A}:.01[e]{0}, B:.02{1})D:.3{3}[g], C:.04{4}[h]) {5};" with self.assertRaises(newickreader.NewickReader.NewickReaderMalformedStatementError): try: tree = dendropy.Tree.get_from_string(s, "newick", is_parse_jplace_tokens=True) except newickreader.NewickReader.NewickReaderMalformedStatementError as e: self.assertEqual( # extra 2nd element of list "Expecting ':', '{', ')', ',' or ';' after reading label but found '}'", e.message) raise e class NewickInternalLabelAssociationTest(unittest.TestCase): def test_assign_to_edges(self): s = "((C:1.3,D:4.0)34:0.034,(A:1.1,(B:1.2,X:1.6)26:0.026)12:0.0126,E:1.5)seed;" expected_labels = { 0 :"seed", 60 :"34", 28 :"12", 24 :"26", } for labels_to_edges in (True, False): for rooting in ("force-rooted", "force-unrooted"): tree = dendropy.Tree.get( data=s, schema="newick", is_assign_internal_labels_to_edges=labels_to_edges) tree.encode_bipartitions() for nd in tree: if nd.is_leaf(): continue expected_label = expected_labels[int(nd.bipartition)] if labels_to_edges: self.assertIs(nd.label, None) self.assertEquals(nd.edge.label, expected_label) else: self.assertEquals(nd.label, expected_label) self.assertIs(nd.edge.label, None) if __name__ == "__main__": unittest.main()