def setUp(self):
self.splits_test_cases = [
PaupWrapperDumbTests.SplitsTestCase("feb032009.tre",
"feb032009.tre",
"feb032009.splits.csv",
100),
]
from dendropy.tests import is_test_enabled, TestLevel
if is_test_enabled(TestLevel.SLOW, _LOG, module_name=__name__, message="skipping large tree files"):
self.splits_test_cases.append(
PaupWrapperDumbTests.SplitsTestCase("terrarana.random.unrooted.100.tre",
"terrarana.random.unrooted.100.tre",
"terrarana.random.unrooted.100.splits.csv",
100))
self.splits_test_cases.append(
PaupWrapperDumbTests.SplitsTestCase("anolis.mcmct.trees.nexus",
"anolis.chars.nexus",
"anolis.mcmct.trees.splits.csv",
1001))
self.taxa_test_cases = (
("feb032009.tre",("T01", "T02", "T03", "T04", "T05", "T06",
"T07", "T08", "T09", "T10", "T11", "T12", "T13", "T14",
"T15", "T16", "T17", "T18", "T19", "T20", "T21", "T22",
"T23", "T24", "T25", "T26", "T27", "T28", "T29", "T30",
"T31", "T32", "T33", "T34", "T35", "T36", "T37", "T38",
"T39", "T40", "T41", "T42", "T43", "T44", "T45", "T46",
"T47", "T48", "T49", "T50", "T51", "T52", "T53", "T54",
"T55", "T56", "T57", "T58", "T59")),
("primates.chars.nexus", ("Lemur catta", "H**o sapiens",
"Pan", "Gorilla", "Pongo", "Hylobates", "Macaca fuscata",
"Macaca mulatta", "Macaca fascicularis", "Macaca sylvanus",
"Saimiri sciureus", "Tarsius syrichta", ))
)
def test3Feb2009MajRuleBug(self):
if not is_test_enabled(TestLevel.NORMAL,
_LOG,
module_name=__name__,
message="skipping sumtree argument tests"):
return
fn1 = dendropy.tests.data_source_path("maj-rule-bug1.tre")
fn2 = dendropy.tests.data_source_path("maj-rule-bug2.tre")
d = Dataset()
tb1 = d.read_trees(open(fn1, "rU"),
format="NEXUS",
encode_splits=True,
rooted=RootingInterpretation.UNROOTED)
tb2 = d.read_trees(open(fn2, "rU"),
format="NEXUS",
encode_splits=True,
rooted=RootingInterpretation.UNROOTED)
taxa1 = d.taxa_blocks[0]
self.assertEqual(taxa1, tb2[0].taxa_block)
firstSD = SplitDistribution(taxa_block=taxa1)
secondSD = SplitDistribution(taxa_block=taxa1)
for o, t in itertools.izip(tb1, tb2):
#encode_splits(o)
#encode_splits(t)
firstSD.count_splits_on_tree(o)
secondSD.count_splits_on_tree(t)
ts = TreeSummarizer()
n_times = 1 # keep set to 1 except for benchmarking tree_from_splits
for i in xrange(n_times):
firstMR = ts.tree_from_splits(firstSD, min_freq=0.5)
secondMR = ts.tree_from_splits(secondSD, min_freq=0.5)
self.assertEqual(0, symmetric_difference(firstMR, secondMR))
BEGIN TAXA;
DIMENSIONS NTAX=5;
TAXLABELS
A
B
C
D
E
;
END;
begin trees;
tree true=(A:0.25,(B:0.25,(C:0.25,(D:0.25,E:0.25):0.25):0.25):0.25):0.25;
end;
"""
if is_test_enabled(TestLevel.SLOW, _LOG, __name__,
"skipping all sequence generation frequency checking"):
class CharGenTest(unittest.TestCase):
def setUp(self):
source_ds = dataio.from_nexus(string=tree_model_string)
self.tree_model = source_ds.trees_blocks[0][0]
def estimate_params(self,
seq_len=10000,
kappa=1.0,
base_freqs=[0.25, 0.25, 0.25, 0.25],
unequal_base_freqs=True,
gamma_rates=False,
prop_invar=False):
output_ds = chargen.generate_hky_dataset(
large_cases = [ #('7180.tre', '7180.tre'),
#('terrarana.random.unrooted.100.tre', 'terrarana.random.unrooted.100.tre'),
('terrarana.random.unrooted.30.tre', 'terrarana.random.rooted.30.tre'),
('anolis.mcmct.trees.nexus', 'anolis.chars.nexus'),
]
small_cases = [
('feb032009.tre', 'feb032009.tre'),
('maj-rule-bug1.tre', 'maj-rule-bug1.tre'),
('maj-rule-bug2.tre', 'maj-rule-bug2.tre'),
]
med_cases = [
('primates.mcmct.trees.nexus', 'primates.chars.nexus'),
]
test_cases = small_cases
if is_test_enabled(TestLevel.NORMAL,
_LOG,
module_name=__name__,
message="skipping medium tree files"):
test_cases.extend(med_cases)
if is_test_enabled(TestLevel.SLOW,
_LOG,
module_name=__name__,
message="skipping large tree files"):
test_cases.extend(large_cases)
class SplitFreqsTest(unittest.TestCase):
def testSplits(self):
unrooted = True
for tc in test_cases:
tree_filepaths = [dendropy.tests.data_source_path(tc[0])]
taxa_filepath = dendropy.tests.data_source_path(tc[1])
def testSumTreeOptions(self):
support_file = dendropy.tests.data_source_path(
"anolis.mbcon.trees.nexus")
target_file = dendropy.tests.data_source_path(
"anolis.mbcon.trees.nexus")
outfile = tempfile.mktemp()
# default options,
self.runSumTrees([support_file])
if not is_test_enabled(TestLevel.SLOW,
_LOG,
module_name=__name__,
message="skipping sumtree argument tests"):
return
# default options, multiple files
self.runSumTrees([support_file, support_file, support_file])
# burnin
self.runSumTrees(["--burnin=100", support_file])
# target tree
self.runSumTrees(["--target=%s" % target_file, support_file])
# 95% consensus tree
self.runSumTrees(["--min-clade-freq=0.95", support_file])
# no branch lengths
self.runSumTrees(["--no-branch-lengths", support_file])
# support as labels
self.runSumTrees(["--support-as-labels", support_file])
# support as branch lengths
self.runSumTrees(["--support-as-lengths", support_file])
# support as percentages
self.runSumTrees(["--percentages", support_file])
# support decimals
self.runSumTrees(["--decimals=0", support_file])
# output to tmp file
if os.path.exists(outfile):
os.remove(outfile)
self.runSumTrees(["--output=%s" % outfile, support_file])
self.runSumTrees(["--replace --output=%s" % outfile, support_file])
if os.path.exists(outfile):
os.remove(outfile)
# no taxa block
self.runSumTrees(["--no-taxa-block", support_file])
# no taxa block
self.runSumTrees(["--no-meta-comments", support_file])
# additional comments
self.runSumTrees(["-m 'Test run of SumTrees'", support_file])
# newick format
self.runSumTrees(["--to-newick", support_file])
# ignore missing support files
self.runSumTrees(["--ignore-missing-support", support_file, "dummy"])
# ignore missing target
self.runSumTrees(
["--ignore-missing-target", "--target=dummy", support_file])
# quiet
self.runSumTrees(["--quiet", support_file])
def testSimple(self):
if not is_test_enabled(TestLevel.SLOW,
_LOG,
module_name=__name__,
message="skipping all rotation scm tests"):
return
clades = ['A', 'D', None, None]
for m in [0, 1]:
four_sisters = ['B', 'C']
clades[2] = '(%s,%s)' % (four_sisters[m], four_sisters[1 - m])
for i in [0, 1, 2]:
for j in [0, 1, 2]:
if i == j:
continue
k = [0, 1, 2]
k.remove(i)
k.remove(j)
k = k[0]
base = [clades[i], clades[j], clades[k]]
four_taxon_newick = '(%s)' % ','.join(base)
for ii in [0, 1, 2]:
for jj in [0, 1, 2]:
if ii == jj:
continue
kk = [0, 1, 2]
kk.remove(ii)
kk.remove(jj)
kk = kk[0]
base = [clades[ii], clades[jj], clades[kk]]
for n in range(4):
if n == 0:
for p in range(4):
c = copy.copy(base)
c.insert(p, 'E')
five_taxon_newick = '(%s)' % ','.join(
c)
self.dofour_five_compat(
four_taxon_newick,
five_taxon_newick)
elif n == 1:
for p in range(3):
c = copy.copy(base)
sisters = [base[p], 'E']
for q in [0, 1]:
c[p] = '(%s,%s)' % (sisters[q],
sisters[1 - q])
five_taxon_newick = '(%s)' % ','.join(
c)
self.dofour_five_compat(
four_taxon_newick,
five_taxon_newick)
elif n == 2:
sc = copy.copy(clades)
for p in range(3):
upc = copy.copy(four_sisters)
upc.insert(p, 'E')
sc[2] = '(%s)' % ','.join(upc)
nsc = [sc[ii], sc[jj], sc[kk]]
five_taxon_newick = '(%s)' % ','.join(
nsc)
self.dofour_five_compat(
four_taxon_newick,
five_taxon_newick)
else:
for p in range(2):
for q in range(2):
upc = copy.copy(four_sisters)
s = upc[p]
ns = [s, 'E']
upc[p] = '(%s,%s)' % (ns[q],
ns[1 - q])
for r in range(2):
third = '(%s,%s)' % (
upc[r], upc[1 - r])
nc = [
clades[0], clades[1], third
]
five_taxon_newick = '(%s)' % ','.join(
nc)
self.dofour_five_compat(
four_taxon_newick,
five_taxon_newick)