# Copyright (C) 2009 by Eric Talevich (eric.talevich@gmail.com) # This code is part of the Biopython distribution and governed by its # license. Please see the LICENSE file that should have been included # as part of this package. """Unit tests for the PhyloXML and PhyloXMLIO modules. """ import os import tempfile import unittest from itertools import chain # Python 2.4 doesn't have ElementTree, which PhyloXMLIO needs from Bio import MissingExternalDependencyError try: from Bio.Phylo import PhyloXML as PX, PhyloXMLIO except ImportError: raise MissingExternalDependencyError( "Install an ElementTree implementation if you want to use " "Bio.Phylo to parse phyloXML files.") from Bio import Alphabet from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord from Bio.Align import MultipleSeqAlignment # Example PhyloXML files EX_APAF = 'PhyloXML/apaf.xml' EX_BCL2 = 'PhyloXML/bcl_2.xml' EX_MADE = 'PhyloXML/made_up.xml' EX_PHYLO = 'PhyloXML/phyloxml_examples.xml' EX_DOLLO = 'PhyloXML/o_tol_332_d_dollo.xml' # Temporary file name for Writer tests below DUMMY = tempfile.mktemp() # --------------------------------------------------------- # Parser tests def _test_read_factory(source, count): """Generate a test method for read()ing the given source. The generated function reads an example file to produce a phyloXML object, then tests for existence of the root node, and counts the number of phylogenies under the root. """ fname = os.path.basename(source) def test_read(self): phx = PhyloXMLIO.read(source) self.assertTrue(phx) self.assertEqual(len(phx), count[0]) self.assertEqual(len(phx.other), count[1]) test_read.__doc__ = "Read %s to produce a phyloXML object." % fname return test_read def _test_parse_factory(source, count): """Generate a test method for parse()ing the given source. The generated function extracts each phylogenetic tree using the parse() function and counts the total number of trees extracted. """ fname = os.path.basename(source) def test_parse(self): trees = PhyloXMLIO.parse(source) self.assertEqual(len(list(trees)), count) test_parse.__doc__ = "Parse the phylogenies in %s." % fname return test_parse def _test_shape_factory(source, shapes): """Generate a test method for checking tree shapes. Counts the branches at each level of branching in a phylogenetic tree, 3 clades deep. """ fname = os.path.basename(source) def test_shape(self): trees = PhyloXMLIO.parse(source) for tree, shape_expect in zip(trees, shapes): self.assertEqual(len(tree.clade), len(shape_expect)) for clade, sub_expect in zip(tree.clade, shape_expect): self.assertEqual(len(clade), sub_expect[0]) for subclade, len_expect in zip(clade, sub_expect[1]): self.assertEqual(len(subclade), len_expect) test_shape.__doc__ = "Check the branching structure of %s." % fname return test_shape class ParseTests(unittest.TestCase): """Tests for proper parsing of example phyloXML files.""" test_read_apaf = _test_read_factory(EX_APAF, (1, 0)) test_read_bcl2 = _test_read_factory(EX_BCL2, (1, 0)) test_read_made = _test_read_factory(EX_MADE, (6, 0)) test_read_phylo = _test_read_factory(EX_PHYLO, (13, 1)) test_read_dollo = _test_read_factory(EX_DOLLO, (1, 0)) test_parse_apaf = _test_parse_factory(EX_APAF, 1) test_parse_bcl2 = _test_parse_factory(EX_BCL2, 1) test_parse_made = _test_parse_factory(EX_MADE, 6) test_parse_phylo = _test_parse_factory(EX_PHYLO, 13) test_parse_dollo = _test_parse_factory(EX_DOLLO, 1) test_shape_apaf = _test_shape_factory(EX_APAF, # lvl-2 clades, sub-clade counts, lvl-3 clades ( ( (2, (2, 2)), (2, (2, 2)), ), ), ) test_shape_bcl2 = _test_shape_factory(EX_BCL2, ( ( (2, (2, 2)), (2, (2, 2)), ), ), ) test_shape_phylo = _test_shape_factory(EX_PHYLO, ( ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (0, ()), (2, (0, 0)), ), ( (3, (0, 0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ( (2, (0, 0)), (0, ()), ), ), ) test_shape_dollo = _test_shape_factory(EX_DOLLO, ( ( (2, (2, 2)), (2, (2, 2)), ), ), ) class TreeTests(unittest.TestCase): """Tests for instantiation and attributes of each complex type.""" # ENH: also test check_str() regexps wherever they're used def test_Phyloxml(self): """Instantiation of Phyloxml objects.""" phx = PhyloXMLIO.read(EX_PHYLO) self.assertTrue(isinstance(phx, PX.Phyloxml)) for tree in phx: self.assertTrue(isinstance(tree, PX.Phylogeny)) for otr in phx.other: self.assertTrue(isinstance(otr, PX.Other)) def test_Other(self): """Instantiation of Other objects.""" phx = PhyloXMLIO.read(EX_PHYLO) otr = phx.other[0] self.assertTrue(isinstance(otr, PX.Other)) self.assertEqual(otr.tag, 'alignment') self.assertEqual(otr.namespace, 'http://example.org/align') self.assertEqual(len(otr.children), 3) for child, name, value in zip(otr, ('A', 'B', 'C'), ( 'acgtcgcggcccgtggaagtcctctcct', 'aggtcgcggcctgtggaagtcctctcct', 'taaatcgc--cccgtgg-agtccc-cct')): self.assertEqual(child.tag, 'seq') self.assertEqual(child.attributes['name'], name) self.assertEqual(child.value, value) def test_Phylogeny(self): """Instantiation of Phylogeny objects.""" trees = list(PhyloXMLIO.parse(EX_PHYLO)) # Monitor lizards self.assertEqual(trees[9].name, 'monitor lizards') self.assertEqual(trees[9].description, 'a pylogeny of some monitor lizards') self.assertEqual(trees[9].rooted, True) # Network (unrooted) tree6 = trees[6] self.assertEqual(trees[6].name, 'network, node B is connected to TWO nodes: AB and C') self.assertEqual(trees[6].rooted, False) def test_Clade(self): """Instantiation of Clade objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[6] clade_ab, clade_c = tree.clade.clades clade_a, clade_b = clade_ab.clades for clade, id_source, name, blen in zip( (clade_ab, clade_a, clade_b, clade_c), ('ab', 'a', 'b', 'c'), ('AB', 'A', 'B', 'C'), (0.06, 0.102, 0.23, 0.4)): self.assertTrue(isinstance(clade, PX.Clade)) self.assertEqual(clade.id_source, id_source) self.assertEqual(clade.name, name) self.assertAlmostEqual(clade.branch_length, blen) def test_Annotation(self): """Instantiation of Annotation objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[3] ann = tree.clade[1].sequences[0].annotations[0] self.assertTrue(isinstance(ann, PX.Annotation)) self.assertEqual(ann.desc, 'alcohol dehydrogenase') self.assertAlmostEqual(ann.confidence.value, 0.67) self.assertEqual(ann.confidence.type, 'probability') def test_BinaryCharacters(self): """Instantiation of BinaryCharacters objects.""" tree = PhyloXMLIO.parse(EX_DOLLO).next() bchars = tree.clade[0,0].binary_characters self.assertTrue(isinstance(bchars, PX.BinaryCharacters)) self.assertEqual(bchars.type, 'parsimony inferred') for name, count, value in ( ('gained', 2, ['Cofilin_ADF', 'Gelsolin']), ('lost', 0, []), ('present', 2, ['Cofilin_ADF', 'Gelsolin']), ('absent', None, []), ): self.assertEqual(getattr(bchars, name+'_count'), count) self.assertEqual(getattr(bchars, name), value) # TODO: BranchColor -- see made_up.xml def test_CladeRelation(self): """Instantiation of CladeRelation objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[6] crel = tree.clade_relations[0] self.assertTrue(isinstance(crel, PX.CladeRelation)) self.assertEqual(crel.id_ref_0, 'b') self.assertEqual(crel.id_ref_1, 'c') self.assertEqual(crel.type, 'network_connection') def test_Confidence(self): """Instantiation of Confidence objects.""" tree = PhyloXMLIO.parse(EX_MADE).next() self.assertEqual(tree.name, 'testing confidence') for conf, type, val in zip(tree.confidences, ('bootstrap', 'probability'), (89.0, 0.71)): self.assertTrue(isinstance(conf, PX.Confidence)) self.assertEqual(conf.type, type) self.assertAlmostEqual(conf.value, val) self.assertEqual(tree.clade.name, 'b') self.assertAlmostEqual(tree.clade.width, 0.2) for conf, val in zip(tree.clade[0].confidences, (0.9, 0.71)): self.assertTrue(isinstance(conf, PX.Confidence)) self.assertEqual(conf.type, 'probability') self.assertAlmostEqual(conf.value, val) def test_Date(self): """Instantiation of Date objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[11] silurian = tree.clade[0,0].date devonian = tree.clade[0,1].date ediacaran = tree.clade[1].date for date, desc, val in zip( (silurian, devonian, ediacaran), # (10, 20, 30), # range is deprecated ('Silurian', 'Devonian', 'Ediacaran'), (425, 320, 600)): self.assertTrue(isinstance(date, PX.Date)) self.assertEqual(date.unit, 'mya') # self.assertAlmostEqual(date.range, rang) self.assertEqual(date.desc, desc) self.assertAlmostEqual(date.value, val) def test_Distribution(self): """Instantiation of Distribution objects. Also checks Point type and safe Unicode handling (?). """ tree = list(PhyloXMLIO.parse(EX_PHYLO))[10] hirschweg = tree.clade[0,0].distributions[0] nagoya = tree.clade[0,1].distributions[0] eth_zurich = tree.clade[0,2].distributions[0] san_diego = tree.clade[1].distributions[0] for dist, desc, lati, longi, alti in zip( (hirschweg, nagoya, eth_zurich, san_diego), ('Hirschweg, Winterthur, Switzerland', 'Nagoya, Aichi, Japan', u'ETH Z\xfcrich', 'San Diego'), (47.481277, 35.155904, 47.376334, 32.880933), (8.769303, 136.915863, 8.548108, -117.217543), (472, 10, 452, 104)): self.assertTrue(isinstance(dist, PX.Distribution)) self.assertEqual(dist.desc, desc) point = dist.points[0] self.assertTrue(isinstance(point, PX.Point)) self.assertEqual(point.geodetic_datum, 'WGS84') self.assertEqual(point.lat, lati) self.assertEqual(point.long, longi) self.assertEqual(point.alt, alti) def test_DomainArchitecture(self): """Instantiation of DomainArchitecture objects. Also checks ProteinDomain type. """ tree = PhyloXMLIO.parse(EX_APAF).next() clade = tree.clade[0,0,0,0,0,0,0,0,0,0] darch = clade.sequences[0].domain_architecture self.assertTrue(isinstance(darch, PX.DomainArchitecture)) self.assertEqual(darch.length, 1249) for domain, start, end, conf, value in zip(darch.domains, (6, 109, 605, 647, 689, 733, 872, 993, 1075, 1117, 1168), (90, 414, 643, 685, 729, 771, 910, 1031, 1113, 1155, 1204), (7.0e-26, 7.2e-117, 2.4e-6, 1.1e-12, 2.4e-7, 4.7e-14, 2.5e-8, 4.6e-6, 6.3e-7, 1.4e-7, 0.3), ('CARD', 'NB-ARC', 'WD40', 'WD40', 'WD40', 'WD40', 'WD40', 'WD40', 'WD40', 'WD40', 'WD40')): self.assertTrue(isinstance(domain, PX.ProteinDomain)) self.assertEqual(domain.start + 1, start) self.assertEqual(domain.end, end) self.assertAlmostEqual(domain.confidence, conf) self.assertEqual(domain.value, value) def test_Events(self): """Instantiation of Events objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[4] event_s = tree.clade.events self.assertTrue(isinstance(event_s, PX.Events)) self.assertEqual(event_s.speciations, 1) event_d = tree.clade[0].events self.assertTrue(isinstance(event_d, PX.Events)) self.assertEqual(event_d.duplications, 1) def test_Polygon(self): """Instantiation of Polygon objects.""" tree = PhyloXMLIO.read(EX_MADE).phylogenies[1] self.assertEqual(tree.name, 'testing polygon') dist = tree.clade[0].distributions[0] for poly in dist.polygons: self.assertTrue(isinstance(poly, PX.Polygon)) self.assertEqual(len(poly.points), 3) self.assertEqual(dist.polygons[0].points[0].alt_unit, 'm') for point, lati, longi, alti in zip( chain(dist.polygons[0].points, dist.polygons[1].points), (47.481277, 35.155904, 47.376334, 40.481277, 25.155904, 47.376334), (8.769303, 136.915863, 8.548108, 8.769303, 136.915863, 7.548108), (472, 10, 452, 42, 10, 452), ): self.assertTrue(isinstance(point, PX.Point)) self.assertEqual(point.geodetic_datum, 'WGS84') self.assertEqual(point.lat, lati) self.assertEqual(point.long, longi) self.assertEqual(point.alt, alti) def test_Property(self): """Instantiation of Property objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[8] for prop, id_ref, value in zip( tree.properties, ('id_a', 'id_b', 'id_c'), ('1200', '2300', '200')): self.assertTrue(isinstance(prop, PX.Property)) self.assertEqual(prop.id_ref, id_ref) self.assertEqual(prop.datatype, "xsd:integer") self.assertEqual(prop.ref, "NOAA:depth") self.assertEqual(prop.applies_to, "node") self.assertEqual(prop.unit, "METRIC:m" ) self.assertEqual(prop.value, value) def test_Reference(self): """Instantiation of Reference objects.""" tree = PhyloXMLIO.parse(EX_DOLLO).next() reference = tree.clade[0,0,0,0,0,0].references[0] self.assertTrue(isinstance(reference, PX.Reference)) self.assertEqual(reference.doi, '10.1038/nature06614') self.assertEqual(reference.desc, None) def test_Sequence(self): """Instantiation of Sequence objects. Also checks Accession and Annotation types. """ trees = list(PhyloXMLIO.parse(EX_PHYLO)) # Simple element with id_source seq0 = trees[4].clade[1].sequences[0] self.assertTrue(isinstance(seq0, PX.Sequence)) self.assertEqual(seq0.id_source, 'z') self.assertEqual(seq0.symbol, 'ADHX') self.assertEqual(seq0.accession.source, 'ncbi') self.assertEqual(seq0.accession.value, 'Q17335') self.assertEqual(seq0.name, 'alcohol dehydrogenase') self.assertEqual(seq0.annotations[0].ref, 'InterPro:IPR002085') # More complete elements seq1 = trees[5].clade[0,0].sequences[0] seq2 = trees[5].clade[0,1].sequences[0] seq3 = trees[5].clade[1].sequences[0] for seq, sym, acc, name, mol_seq, ann_refs in zip( (seq1, seq2, seq3), ('ADHX', 'RT4I1', 'ADHB'), ('P81431', 'Q54II4', 'Q04945'), ('Alcohol dehydrogenase class-3', 'Reticulon-4-interacting protein 1 homolog, ' \ 'mitochondrial precursor', 'NADH-dependent butanol dehydrogenase B'), ('TDATGKPIKCMAAIAWEAKKPLSIEEVEVAPPKSGEVRIKILHSGVCHTD', 'MKGILLNGYGESLDLLEYKTDLPVPKPIKSQVLIKIHSTSINPLDNVMRK', 'MVDFEYSIPTRIFFGKDKINVLGRELKKYGSKVLIVYGGGSIKRNGIYDK'), (("EC:1.1.1.1", "GO:0004022"), ("GO:0008270", "GO:0016491"), ("GO:0046872", "KEGG:Tetrachloroethene degradation")), ): self.assertTrue(isinstance(seq, PX.Sequence)) self.assertEqual(seq.symbol, sym) self.assertEqual(seq.accession.source, 'UniProtKB') self.assertEqual(seq.accession.value, acc) self.assertEqual(seq.name, name) self.assertEqual(seq.mol_seq.value, mol_seq) self.assertEqual(seq.annotations[0].ref, ann_refs[0]) self.assertEqual(seq.annotations[1].ref, ann_refs[1]) def test_SequenceRelation(self): """Instantiation of SequenceRelation objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[4] for seqrel, id_ref_0, id_ref_1, type in zip( tree.sequence_relations, ('x', 'x', 'y'), ('y', 'z', 'z'), ('paralogy', 'orthology', 'orthology')): self.assertTrue(isinstance(seqrel, PX.SequenceRelation)) self.assertEqual(seqrel.id_ref_0, id_ref_0) self.assertEqual(seqrel.id_ref_1, id_ref_1) self.assertEqual(seqrel.type, type) def test_Taxonomy(self): """Instantiation of Taxonomy objects. Also checks Id type. """ trees = list(PhyloXMLIO.parse(EX_PHYLO)) # Octopus tax5 = trees[5].clade[0,0].taxonomies[0] self.assertTrue(isinstance(tax5, PX.Taxonomy)) self.assertEqual(tax5.id.value, '6645') self.assertEqual(tax5.id.provider, 'NCBI') self.assertEqual(tax5.code, 'OCTVU') self.assertEqual(tax5.scientific_name, 'Octopus vulgaris') # Nile monitor tax9 = trees[9].clade[0].taxonomies[0] self.assertTrue(isinstance(tax9, PX.Taxonomy)) self.assertEqual(tax9.id.value, '62046') self.assertEqual(tax9.id.provider, 'NCBI') self.assertEqual(tax9.scientific_name, 'Varanus niloticus') self.assertEqual(tax9.common_names[0], 'Nile monitor') self.assertEqual(tax9.rank, 'species') def test_Uri(self): """Instantiation of Uri objects.""" tree = list(PhyloXMLIO.parse(EX_PHYLO))[9] uri = tree.clade.taxonomies[0].uri self.assertTrue(isinstance(uri, PX.Uri)) self.assertEqual(uri.desc, 'EMBL REPTILE DATABASE') self.assertEqual(uri.value, 'http://www.embl-heidelberg.de/~uetz/families/Varanidae.html') # --------------------------------------------------------- # Serialization tests class WriterTests(unittest.TestCase): """Tests for serialization of objects to phyloXML format. Modifies the globally defined filenames in order to run the other parser tests on files (re)generated by PhyloXMLIO's own writer. """ def _rewrite_and_call(self, orig_fname, test_cases): """Parse, rewrite and retest a phyloXML example file.""" infile = open(orig_fname, 'rb') phx = PhyloXMLIO.read(infile) infile.close() outfile = open(DUMMY, 'w+b') PhyloXMLIO.write(phx, outfile) outfile.close() for cls, tests in test_cases: inst = cls('setUp') for test in tests: getattr(inst, test)() def test_apaf(self): """Round-trip parsing and serialization of apaf.xml.""" global EX_APAF orig_fname = EX_APAF try: EX_APAF = DUMMY self._rewrite_and_call(orig_fname, ( (ParseTests, [ 'test_read_apaf', 'test_parse_apaf', 'test_shape_apaf']), (TreeTests, ['test_DomainArchitecture']), )) finally: EX_APAF = orig_fname def test_bcl2(self): """Round-trip parsing and serialization of bcl_2.xml.""" global EX_BCL2 orig_fname = EX_BCL2 try: EX_BCL2 = DUMMY self._rewrite_and_call(orig_fname, ( (ParseTests, [ 'test_read_bcl2', 'test_parse_bcl2', 'test_shape_bcl2']), (TreeTests, ['test_Confidence']), )) finally: EX_BCL2 = orig_fname def test_made(self): """Round-trip parsing and serialization of made_up.xml.""" global EX_MADE orig_fname = EX_MADE try: EX_MADE = DUMMY self._rewrite_and_call(orig_fname, ( (ParseTests, ['test_read_made', 'test_parse_made']), (TreeTests, ['test_Confidence', 'test_Polygon']), )) finally: EX_MADE = orig_fname def test_phylo(self): """Round-trip parsing and serialization of phyloxml_examples.xml.""" global EX_PHYLO orig_fname = EX_PHYLO try: EX_PHYLO = DUMMY self._rewrite_and_call(orig_fname, ( (ParseTests, [ 'test_read_phylo', 'test_parse_phylo', 'test_shape_phylo']), (TreeTests, [ 'test_Phyloxml', 'test_Other', 'test_Phylogeny', 'test_Clade', 'test_Annotation', 'test_CladeRelation', 'test_Date', 'test_Distribution', 'test_Events', 'test_Property', 'test_Sequence', 'test_SequenceRelation', 'test_Taxonomy', 'test_Uri', ]), )) finally: EX_PHYLO = orig_fname def test_dollo(self): """Round-trip parsing and serialization of o_tol_332_d_dollo.xml.""" global EX_DOLLO orig_fname = EX_DOLLO try: EX_DOLLO = DUMMY self._rewrite_and_call(orig_fname, ( (ParseTests, ['test_read_dollo', 'test_parse_dollo']), (TreeTests, ['test_BinaryCharacters']), )) finally: EX_DOLLO = orig_fname # --------------------------------------------------------- # Method tests class MethodTests(unittest.TestCase): """Tests for methods on specific classes/objects.""" def setUp(self): self.phyloxml = PhyloXMLIO.read(EX_PHYLO) # Type conversions def test_clade_to_phylogeny(self): """Convert a Clade object to a new Phylogeny.""" clade = self.phyloxml.phylogenies[0].clade[0] tree = clade.to_phylogeny(rooted=True) self.assertTrue(isinstance(tree, PX.Phylogeny)) def test_phylogeny_to_phyloxml(self): """Convert a Phylogeny object to a new Phyloxml.""" tree = self.phyloxml.phylogenies[0] doc = tree.to_phyloxml_container() self.assertTrue(isinstance(doc, PX.Phyloxml)) def test_sequence_conversion(self): pseq = PX.Sequence( type='protein', # id_ref=None, # id_source=None, symbol='ADHX', accession=PX.Accession('P81431', source='UniProtKB'), name='Alcohol dehydrogenase class-3', # location=None, mol_seq=PX.MolSeq( 'TDATGKPIKCMAAIAWEAKKPLSIEEVEVAPPKSGEVRIKILHSGVCHTD'), uri=None, annotations=[PX.Annotation(ref='EC:1.1.1.1'), PX.Annotation(ref='GO:0004022')], domain_architecture=PX.DomainArchitecture( length=50, domains=[PX.ProteinDomain(*args) for args in ( # value, start, end, confidence ('FOO', 0, 5, 7.0e-26), ('BAR', 8, 13, 7.2e-117), ('A-OK', 21, 34, 2.4e-06), ('WD40', 40, 50, 0.3))], )) srec = pseq.to_seqrecord() # TODO: check seqrec-specific traits (see args) # Seq(letters, alphabet), id, name, description, features pseq2 = PX.Sequence.from_seqrecord(srec) # TODO: check the round-tripped attributes again def test_to_alignment(self): tree = self.phyloxml.phylogenies[0] aln = tree.to_alignment() self.assertTrue(isinstance(aln, MultipleSeqAlignment)) self.assertEqual(len(aln), 0) # Add sequences to the terminals alphabet = Alphabet.Gapped(Alphabet.generic_dna) for tip, seqstr in zip(tree.get_terminals(), ('AA--TTA', 'AA--TTG', 'AACCTTC')): tip.sequences.append(PX.Sequence.from_seqrecord( SeqRecord(Seq(seqstr, alphabet), id=str(tip)))) # Check the alignment aln = tree.to_alignment() self.assertTrue(isinstance(aln, MultipleSeqAlignment)) self.assertEqual(len(aln), 3) self.assertEqual(aln.get_alignment_length(), 7) # Syntax sugar def test_clade_getitem(self): """Clade.__getitem__: get sub-clades by extended indexing.""" tree = self.phyloxml.phylogenies[3] self.assertEqual(tree.clade[0,0], tree.clade.clades[0].clades[0]) self.assertEqual(tree.clade[0,1], tree.clade.clades[0].clades[1]) self.assertEqual(tree.clade[1], tree.clade.clades[1]) self.assertEqual(len(tree.clade[:]), len(tree.clade.clades)) self.assertEqual(len(tree.clade[0,:]), len(tree.clade.clades[0].clades)) def test_phyloxml_getitem(self): """Phyloxml.__getitem__: get phylogenies by name or index.""" self.assertTrue(self.phyloxml.phylogenies[9] is self.phyloxml[9]) self.assertTrue(self.phyloxml['monitor lizards'] is self.phyloxml[9]) self.assertEqual(len(self.phyloxml[:]), len(self.phyloxml)) def test_events(self): """Events: Mapping-type behavior.""" evts = self.phyloxml.phylogenies[4].clade.events # Container behavior: __len__, __contains__ self.assertEqual(len(evts), 1) self.assertEqual('speciations' in evts, True) self.assertEqual('duplications' in evts, False) # Attribute access: __get/set/delitem__ self.assertEqual(evts['speciations'], 1) self.assertRaises(KeyError, lambda k: evts[k], 'duplications') evts['duplications'] = 3 self.assertEqual(evts.duplications, 3) self.assertEqual(len(evts), 2) del evts['speciations'] self.assertEqual(evts.speciations, None) self.assertEqual(len(evts), 1) # Iteration: __iter__, keys, values, items self.assertEqual(list(iter(evts)), ['duplications']) self.assertEqual(list(evts.keys()), ['duplications']) self.assertEqual(list(evts.values()), [3]) self.assertEqual(list(evts.items()), [('duplications', 3)]) def test_singlular(self): """Clade, Phylogeny: Singular properties for plural attributes.""" conf = PX.Confidence(0.9, 'bootstrap') taxo = PX.Taxonomy(rank='genus') # Clade.taxonomy, Clade.confidence clade = PX.Clade(confidences=[conf], taxonomies=[taxo]) self.assertEqual(clade.confidence.type, 'bootstrap') self.assertEqual(clade.taxonomy.rank, 'genus') # raise if len > 1 clade.confidences.append(conf) self.assertRaises(AttributeError, getattr, clade, 'confidence') clade.taxonomies.append(taxo) self.assertRaises(AttributeError, getattr, clade, 'taxonomy') # None if [] clade.confidences = [] self.assertEqual(clade.confidence, None) clade.taxonomies = [] self.assertEqual(clade.taxonomy, None) # Phylogeny.confidence tree = PX.Phylogeny(True, confidences=[conf]) self.assertEqual(tree.confidence.type, 'bootstrap') tree.confidences.append(conf) self.assertRaises(AttributeError, getattr, tree, 'confidence') tree.confidences = [] self.assertEqual(tree.confidence, None) # Other methods def test_color_hex(self): """BranchColor: to_hex() method.""" black = PX.BranchColor(0, 0, 0) self.assertEqual(black.to_hex(), '#000000') white = PX.BranchColor(255, 255, 255) self.assertEqual(white.to_hex(), '#ffffff') green = PX.BranchColor(14, 192, 113) self.assertEqual(green.to_hex(), '#0ec071') # --------------------------------------------------------- if __name__ == '__main__': runner = unittest.TextTestRunner(verbosity=2) unittest.main(testRunner=runner) # Clean up the temporary file if os.path.exists(DUMMY): os.remove(DUMMY)