o Rŀg@sdZddlZddlZddlZddlZddlZddZddZddZd d Z d d Z d dZ ddZ ddZ ddZddZddZddZGdddZGdddZGdd d eeZGd!d"d"eeZGd#d$d$ZdS)%zBase classes for Bio.Phylo objects. All object representations for phylogenetic trees should derive from these base classes in order to use the common methods defined on them. Nccs:t|g}|r|}|V||||s dSdS)z9Traverse a tree in breadth-first (level) order (PRIVATE).N) collectionsdequepopleftextend)root get_childrenQvr F/var/www/html/myenv/lib/python3.10/site-packages/Bio/Phylo/BaseTree.py_level_traverses  r c#"fdd|EdHdS)zLTraverse a tree in depth-first pre-order (parent before children) (PRIVATE).c3s(|V|D] }|EdHqdSNr elemr dfsrr r r#s  z_preorder_traverse..dfsNr rrr rr _preorder_traverse rc#r )zMTraverse a tree in depth-first post-order (children before parent) (PRIVATE).c3s(|D] }|EdHq|VdSrr rrr r r.s  z _postorder_traverse..dfsNr rr rr _postorder_traverse+rrcCsdg}g}t|jdddD]\}}|durqt|tr#||q||qdd||DS)zGGet a flat list of elem's attributes, sorted for consistency (PRIVATE).cS|dSNrr )kvr r r ;z_sorted_attrs..keyNcss|] }t|tr|VqdSr) isinstance TreeElement).0xr r r Bsz _sorted_attrs..)sorted__dict__itemsrlistrappend)rsingleslistsattrnamechildr r r _sorted_attrs6s   r,cfdd}|S)z8Match a node to the target object by identity (PRIVATE).cs|uSrr nodetargetr r matchKz _identity_matcher..matchr r1r2r r0r _identity_matcherH r5cr-)z>Match a node if it's an instance of the given class (PRIVATE).cs t|Sr)rr. target_clsr r r2Ts z_class_matcher..matchr )r8r2r r7r _class_matcherQr6r9cr-)Ncs$t|ttfr |jkSt|kSr)rCladeTreenamestrr.r0r r r2[s  z_string_matcher..matchr r4r r0r _string_matcherZs r>cr-)aUMatch a node by specified attribute values (PRIVATE). ``terminal`` is a special case: True restricts the search to external (leaf) nodes, False restricts to internal nodes, and None allows all tree elements to be searched, including phyloXML annotations. Otherwise, for a tree element to match the specification (i.e. for the function produced by ``_attribute_matcher`` to return True when given a tree element), it must have each of the attributes specified by the keys and match each of the corresponding values -- think 'and', not 'or', for multiple keys. csdvr}|d}|durt|dr||krdSn}|D]O\}}t||s1dSt||}t|trJt|toGt |d|St|t rW|t |kSt|t rb||kS|durl|duSt dt |dS)Nterminal is_terminalF$zinvalid query type: T)copypophasattrr@r%getattrrr=rer2boolint TypeErrortype)r/kwa_copypatternrr1kwargsr r r2rs0         z!_attribute_matcher..matchr )rNr2r rMr _attribute_matcherds rOcr-)zNSafer attribute lookup -- returns False instead of raising an error (PRIVATE).c s(z|WSttttfyYdSw)NF) LookupErrorAttributeError ValueErrorrIr. matcher_funcr r r2s  z _function_matcher..matchr )rTr2r rSr _function_matchers rUcCspt|tr t|St|trt|St|trt|St|tr$t|St |r,t |St |dt|d)aZRetrieve a matcher function by passing an arbitrary object (PRIVATE). Passing a ``TreeElement`` such as a ``Clade`` or ``Tree`` instance returns an identity matcher, passing a type such as the ``PhyloXML.Taxonomy`` class returns a class matcher, and passing a dictionary returns an attribute matcher. The resulting 'match' function returns True when given an object matching the specification (identity, type or attribute values), otherwise False. This is useful for writing functions that search the tree, and probably shouldn't be used directly by the end user. z (type z%) is not a valid type for comparison.) rrr5rJr9r=r>dictrOcallablerUrR)objr r r _object_matchers    rYcsJ|s|s|r tdddSt|St||sSt|fddS)zMerge target specifications with keyword arguments (PRIVATE). Dispatch the components to the various matcher functions, then merge into a single boolean function. z6you must specify a target object or keyword arguments.cSdS)NTr r!r r r rz#_combine_matchers..cs|o|Srr r[ match_kwargs match_objr r rs)rRrOrY)r1rN require_specr r]r _combine_matcherssracGs:t|drt|ttttfs|rtd|St|g|S)zConvert ``[targets]`` or ``*targets`` arguments to a single iterable (PRIVATE). This helps other functions work like the built-in functions ``max`` and ``min``. __iter__zxArguments must be either a single list of targets, or separately specified targets (e.g. foo(t1, t2, t3)), but not both.) rDrrrVr=rJrR itertoolschain)firstrestr r r _combine_argss rgc@s,eZdZdZdefddZdefddZdS)rz%Base class for all Bio.Phylo classes.returncs6ddd|jjdfddt|jDfS)z.pair_as_kwarg_stringz%s(%s)z, c3s<|]\}}|durt|tttttfvr||VqdSr)rJr=rHfloatrG)r rrorpr r r"sz'TreeElement.__repr__..) __class____name__joinr#r$r%selfr rrr __repr__s zTreeElement.__repr__cC|Sr)rxrvr r r __str__r3zTreeElement.__str__N)rt __module__ __qualname____doc__r=rxrzr r r r rsrc@seZdZdZddZddZd3dd Zd3d d Zd4d d Zd5ddZ d5ddZ ddZ ddZ ddZ d6ddZd4ddZddZdd Zd4d!d"Zd#d$Zd%d&Zd4d'd(Zd4d)d*Zd6d+d,Zd4d-d.Zd7d1d2ZdS)8 TreeMixina5Methods for Tree- and Clade-based classes. This lets ``Tree`` and ``Clade`` support the same traversal and searching operations without requiring Clade to inherit from Tree, so Clade isn't required to have all of Tree's attributes -- just ``root`` (a Clade instance) and ``is_terminal``. c Csntttd}z||}Wnty td|dt|dw|r(t}|}ndd}|j}t||||S)zPerform a BFS or DFS traversal through all elements in this tree (PRIVATE). :returns: generator of all elements for which ``filter_func`` is True. )preorder postorderlevelzInvalid order 'z'; must be one of: NcS|jSrcladesrr r r r#sz*TreeMixin._filter_search..) rrr KeyErrorrRtupler,rfilter)rw filter_funcorder follow_attrs order_opts order_funcrrr r r _filter_search s&  zTreeMixin._filter_searchcOs0|j|i|}zt|WStyYdSw)zReturn the first element found by find_elements(), or None. This is also useful for checking whether any matching element exists in the tree, and can be used in a conditional expression. N) find_elementsnext StopIteration)rwargsrNhitsr r r find_any's   zTreeMixin.find_anyNrcKs*|dur||d<t||d}|||dS)aFind all tree elements matching the given attributes. The arbitrary keyword arguments indicate the attribute name of the sub-element and the value to match: string, integer or boolean. Strings are evaluated as regular expression matches; integers are compared directly for equality, and booleans evaluate the attribute's truth value (True or False) before comparing. To handle nonzero floats, search with a boolean argument, then filter the result manually. If no keyword arguments are given, then just the class type is used for matching. The result is an iterable through all matching objects, by depth-first search. (Not necessarily the same order as the elements appear in the source file!) :Parameters: target : TreeElement instance, type, dict, or callable Specifies the characteristics to search for. (The default, TreeElement, matches any standard Bio.Phylo type.) terminal : bool A boolean value to select for or against terminal nodes (a.k.a. leaf nodes). True searches for only terminal nodes, False excludes terminal nodes, and the default, None, searches both terminal and non-terminal nodes, as well as any tree elements lacking the ``is_terminal`` method. order : {'preorder', 'postorder', 'level'} Tree traversal order: 'preorder' (default) is depth-first search, 'postorder' is DFS with child nodes preceding parents, and 'level' is breadth-first search. Examples -------- >>> from Bio import Phylo >>> phx = Phylo.PhyloXMLIO.read('PhyloXML/phyloxml_examples.xml') >>> matches = phx.phylogenies[5].find_elements(code='OCTVU') >>> next(matches) Taxonomy(code='OCTVU', scientific_name='Octopus vulgaris') Nr?FT)rarrwr1r?rrNis_matching_elemr r r r3s) zTreeMixin.find_elementsc s8fdddur}nfdd}|||dS)a?Find each clade containing a matching element. That is, find each element as with find_elements(), but return the corresponding clade object. (This is usually what you want.) :returns: an iterable through all matching objects, searching depth-first (preorder) by default. cs,|jd}|jfi}||_|duS)Nr)r$rCrr)r orig_cladesfound)rNr1r r match_attrsls z*TreeMixin.find_clades..match_attrsNcs|ko |Sr)r@r)rr?r r rvsz/TreeMixin.find_clades..is_matching_elemF)rrr )rNrr1r?r find_cladesas  zTreeMixin.find_cladesc s<gt||dfdd|jsdSdddS)zList the clades directly between this root and the given target. :returns: list of all clade objects along this path, ending with the given target, but excluding the root clade. TcsH|r |dS|rdS|D]}|r!|dSqdS)NTF)r'r@)r r+ check_in_pathr2pathr r rs  z)TreeMixin.get_path..check_in_pathN)rarrwr1rNr rr get_path{s   zTreeMixin.get_pathcCt|jd|dS)z>Get a list of all of this tree's nonterminal (internal) nodes.Fr?rr&rrwrr r r get_nonterminalszTreeMixin.get_nonterminalscCr)z7Get a list of all of this tree's terminal (leaf) nodes.Trrrr r r get_terminalsrzTreeMixin.get_terminalscCs8|||}||ddd}||}||g|S)zwList of all clade object between two targets in this tree. Excluding ``start``, including ``finish``. rNr)common_ancestorr)rwstartfinishmrca fromstarttor r r traces  zTreeMixin.tracec sfddt|g|RD}t||D]\}}|dur$td|dqj}t|D]}|d}|ddD]} || ur@nq8|}||urJ|Sq,|S)a Most recent common ancestor (clade) of all the given targets. Edge cases: - If no target is given, returns self.root - If 1 target is given, returns the target - If any target is not found in this tree, raises a ValueError csg|]}|qSr r)r trvr r sz-TreeMixin.common_ancestor..Nztarget z is not in this treer)rgziprRr) rwtargets more_targetspathsprrrrefotherr rvr rs$  zTreeMixin.common_ancestorcCtdd|jddDS)z;Count the number of terminal (leaf) nodes within this tree.css|]}dVqdS)rNr )r clader r r r"sz,TreeMixin.count_terminals..T)r?sumrrvr r r count_terminalszTreeMixin.count_terminalsFcsB|rddnddifdd|j|jjpdS)a Create a mapping of tree clades to depths (by branch length). :Parameters: unit_branch_lengths : bool If True, count only the number of branches (levels in the tree). By default the distance is the cumulative branch length leading to the clade. :returns: dict of {clade: depth}, where keys are all of the Clade instances in the tree, and values are the distance from the root to each clade (including terminals). cSrZNrr cr r r rr\z"TreeMixin.depths..cSs |jpdSr branch_lengthrr r r rs cs.||<|jD] }||}||qdSrr)r/ curr_depthr+ new_depthdepth_ofdepths update_depthsr r rs    z'TreeMixin.depths..update_depthsr)rr)rwunit_branch_lengthsr rr rs zTreeMixin.depthscCs@|durtdd||DS|||}||||S)zCalculate the sum of the branch lengths between two targets. If only one target is specified, the other is the root of this tree. Ncss |] }|jdur|jVqdSrr)r nr r r r"s z%TreeMixin.distance..)rrrdistance)rwtarget1target2rr r r rs  zTreeMixin.distancecCst|tr$t|jdkr$|jjdo#|jjdo#|jjdSt|jdkr;|jjdo:|jjdSt|jdkrDdSdS)a#Return True if tree downstream of node is strictly bifurcating. I.e., all nodes have either 2 or 0 children (internal or external, respectively). The root may have 3 descendents and still be considered part of a bifurcating tree, because it has no ancestor. rrTF)rr;rnrris_bifurcatingrvr r r rszTreeMixin.is_bifurcatingcGs\tt|g|R}|j} t||kr|S|jD]}t||r*|}nqdSq)a!MRCA of terminals if they comprise a complete subclade, or False. I.e., there exists a clade such that its terminals are the same set as the given targets. The given targets must be terminals of the tree. To match both ``Bio.Nexus.Trees`` and the other multi-target methods in Bio.Phylo, arguments to this method can be specified either of two ways: (i) as a single list of targets, or (ii) separately specified targets, e.g. is_monophyletic(t1, t2, t3) -- but not both. For convenience, this method returns the common ancestor (MCRA) of the targets if they are monophyletic (instead of the value True), and False otherwise. :returns: common ancestor if terminals are monophyletic, otherwise False. TF)setrgrrr issuperset)rw terminalsmore_terminals target_setcurrentsubclader r r is_monophyletic s zTreeMixin.is_monophyleticcKs|j|fi|duS)zCheck if target is a descendent of this tree. Not required to be a direct descendent. To check only direct descendents of a clade, simply use list membership testing: ``if subclade in clade: ...`` Nrrr r r is_parent_of+szTreeMixin.is_parent_ofcCs.|jrdS|jjD] }|sdSq dS)z-Check if all direct descendents are terminal.FT)rr@r)rwrr r r is_preterminal5s  zTreeMixin.is_preterminalcCr)z9Calculate the sum of all the branch lengths in this tree.css|]}|jVqdSrr)r r/r r r r"@sz0TreeMixin.total_branch_length..Trrrvr r r total_branch_length>rzTreeMixin.total_branch_lengthcKs|j|fi|}|std|p|t|dkr|j}n|d}|j|j|d}|jp1d}|D] }|j|7_q4|j|j|S)zqDelete target from the tree, relinking its children to its parent. :returns: the parent clade. z!couldn't collapse %s in this treerrrr) rrRrnrrrCindexrr)rwr1rNrparentpopped extra_lengthr+r r r collapseDs  zTreeMixin.collapsecKsRt|j|ddfi|}|sdS|d|jkr|d|D]}||qdS)aCollapse all the descendents of this tree, leaving only terminals. Total branch lengths are preserved, i.e. the distance to each terminal stays the same. For example, this will safely collapse nodes with poor bootstrap support: >>> from Bio import Phylo >>> tree = Phylo.read('PhyloXML/apaf.xml', 'phyloxml') >>> print("Total branch length %0.2f" % tree.total_branch_length()) Total branch length 20.44 >>> tree.collapse_all(lambda c: c.confidence is not None and c.confidence < 70) >>> print("Total branch length %0.2f" % tree.total_branch_length()) Total branch length 21.37 This implementation avoids strange side-effects by using level-order traversal and testing all clade properties (versus the target specification) up front. In particular, if a clade meets the target specification in the original tree, it will be collapsed. For example, if the condition is: >>> from Bio import Phylo >>> tree = Phylo.read('PhyloXML/apaf.xml', 'phyloxml') >>> print("Total branch length %0.2f" % tree.total_branch_length()) Total branch length 20.44 >>> tree.collapse_all(lambda c: c.branch_length < 0.1) >>> print("Total branch length %0.2f" % tree.total_branch_length()) Total branch length 21.13 Collapsing a clade's parent node adds the parent's branch length to the child, so during the execution of collapse_all, a clade's branch_length may increase. In this implementation, clades are collapsed according to their properties in the original tree, not the properties when tree traversal reaches the clade. (It's easier to debug.) If you want the other behavior (incremental testing), modifying the source code of this function is straightforward. FrNr)r&rrrCr)rwr1rNmatchesrr r r collapse_allXs(  zTreeMixin.collapse_allcCs4|jjjdd|d|jjD]}|j|dqdS)zSort clades in-place according to the number of terminal nodes. Deepest clades are last by default. Use ``reverse=True`` to sort clades deepest-to-shallowest. cSryr)rrr r r rrz%TreeMixin.ladderize..)rreverse)rN)rrsort ladderize)rwrrr r r rs zTreeMixin.ladderizec Ks d|vr |dr td|j|fddi|}|stdt|dkr'|j}n|d}|j|dt|dkr||jkrM|jd}d |_|}|_|S|jd}|jd ura|j|jp^d 7_t|d krk|j}n|d }|j|}|j||j |||}|S) a+Prunes a terminal clade from the tree. If taxon is from a bifurcation, the connecting node will be collapsed and its branch length added to remaining terminal node. This might be no longer be a meaningful value. :returns: parent clade of the pruned target r?ztarget must be terminalTz,can't find a matching target below this rootrrrrNr) rRrrnrrremoverrrCinsert) rwr1rNrrnewrootr+ grandparentrr r r prunes4          zTreeMixin.pruner?cCsJt|j}|jjp d}t|D]}||t||d}|jj|qdS)aGenerate n (default 2) new descendants. In a species tree, this is a speciation event. New clades have the given branch_length and the same name as this clade's root plus an integer suffix (counting from 0). For example, splitting a clade named "A" produces sub-clades named "A0" and "A1". If the clade has no name, the prefix "n" is used for child nodes, e.g. "n0" and "n1". r)r<rN)rJrr<ranger=rr')rwrr clade_cls base_nameirr r r splits  zTreeMixin.split)NNrr)r)F)rr)rtr{r|r}rrrrrrrrrrrrrrrrrrrrrrr r r r r~s0  .       !    2 ,r~c@seZdZdZdddZeddZedd d Zed d Z d dZ ddddZ ddZ ddZ ddZdddZdefddZdS) r;aaA phylogenetic tree, containing global info for the phylogeny. The structure and node-specific data is accessible through the 'root' clade attached to the Tree instance. :Parameters: root : Clade The starting node of the tree. If the tree is rooted, this will usually be the root node. rooted : bool Whether or not the tree is rooted. By default, a tree is assumed to be rooted. id : str The identifier of the tree, if there is one. name : str The name of the tree, in essence a label. NTcCs"|pt|_||_||_||_dS)z+Initialize parameter for phylogenetic tree.N)r:rrootedidr<)rwrrrr<r r r __init__s  z Tree.__init__cKst|}||fi|S)zzCreate a new Tree object given a clade. Keyword arguments are the usual ``Tree`` constructor parameters. )rBdeepcopy)clsrrNrr r r from_clades zTree.from_claderc Cst|trddt|D}nt|drt|}ntd|}|jg}t|t|kr]t |}|j |d|j }|rK|D] }t dt |||_q>||||t|t|ks,t|t||D]\} } | | _qg|S)a/Create a randomized bifurcating tree given a list of taxa. :param taxa: Either an integer specifying the number of taxa to create (automatically named taxon#), or an iterable of taxon names, as strings. :returns: a tree of the same type as this class. cSsg|] }d|dqS)taxonrr )r rr r r rsz#Tree.randomized..rbzBtaxa argument must be integer (# taxa) or iterable of taxon names.rr)rrHrrDr&rIrrnrandomchoicerrmaxgaussrrrshufflerr<) rtaxar branch_stdevrtreernewsplitnewtermsntr/r<r r r randomizeds.        zTree.randomizedcCr)z-Return first clade in this tree (not itself).)rrvr r r rsz Tree.cladecKsddlm}|j|fi|S)zConvert this tree to a PhyloXML-compatible Phylogeny. This lets you use the additional annotation types PhyloXML defines, and save this information when you write this tree as 'phyloxml'. r) Phylogeny)Bio.Phylo.PhyloXMLr  from_tree)rwrNr r r r as_phyloxml s zTree.as_phyloxmloutgroup_branch_lengthc Gs|j|g|R}||}t|dkrdS|jpd}|s#|dur_|p&d|_|jj|jj|gd}t|dkr<|}n,|d} | j| j || j||j}| _|j d| | }n |}|jj|_|}|dddD]} | j| j || j|}| _|j d| | }qo|j} || jvrt|dksJ| j| j |n | j| j |t| dkr| jd} | jr| j|7_n|| _|j d| n || _|j d| ||_d|_ dS) aReroot this tree with the outgroup clade containing outgroup_targets. Operates in-place. Edge cases: - If ``outgroup == self.root``, no change - If outgroup is terminal, create new bifurcating root node with a 0-length branch to the outgroup - If outgroup is internal, use the given outgroup node as the new trifurcating root, keeping branches the same - If the original root was bifurcating, drop it from the tree, preserving total branch lengths :param outgroup_branch_length: length of the branch leading to the outgroup after rerooting. If not specified (None), then: - If the outgroup is an internal node (not a single terminal taxon), then use that node as the new root. - Otherwise, create a new root node as the parent of the outgroup. rNr)rrrrrT) rrrnrr@rrsrCrrrr) rwoutgroup_targetsrroutgroup outgroup_path prev_blennew_root new_parentrold_rootingroupr r r root_with_outgroup*sT            zTree.root_with_outgroupc Csd}|}|D]#}||t|ddd}|d|kr+|}|d}|d}q||d||jjp8d}|dksAJ||D]}||j8}|dkrX|} | } nqFtd|j| | d d S) aRoot the tree at the midpoint of the two most distant taxa. This operates in-place, leaving a bifurcating root. The topology of the tree is otherwise retained, though no guarantees are made about the stability of clade/node/taxon ordering. rcSrrr )ndr r r rrz'Tree.root_at_midpoint..rrrg?z%Somehow, failed to find the midpoint!r N) rrrrr%rrrrR) rw max_distancetipstipnew_maxtip1tip2root_remainderr/ outgroup_noderr r r root_at_midpoints0      zTree.root_at_midpointcCs |jj S)z+Check if the root of this tree is terminal.)rrrvr r r r@ zTree.is_terminalcCsB|rddlm}ddlm}|}||g|||St|S)aSerialize the tree as a string in the specified file format. This method supports Python's ``format`` built-in function. :param format_spec: a lower-case string supported by ``Bio.Phylo.write`` as an output file format. r)StringIO)_io)ior# Bio.Phylor$writegetvaluer=)rw format_specr#r$handler r r __format__s  zTree.__format__cCs ||S)zSerialize the tree as a string in the specified file format. :param fmt: a lower-case string supported by ``Bio.Phylo.write`` as an output file format. )r+)rwfmtr r r formats z Tree.formatrhcs,dgfdd|ddS)zReturn a string representation of the entire tree. Serialize each sub-clade recursively using ``repr`` to create a summary of the object structure. z cst|ttfr t|}nt|}|||d7}|jD]&}t||}t|tr2||q t|t rF|D] }t|trE||q9q dS)zrRecursively serialize sub-elements. This closes over textlines and modifies it in-place. rN) rr;r:reprr=r'r$rErr&)rXindentobjstrattrr+rTAB print_tree textlinesr r r4s        z Tree.__str__..print_treer )rurvr r2r rzs   z Tree.__str__)NTNN)rNr)rtr{r|r}r classmethodrrpropertyrr rr!r@r+r-r=rzr r r r r;s"   $  _&  r;c@seZdZdZ      dddZeddZddZd d Zd d Z d dZ ddZ de fddZ ddZddZeeeddZdS)r:a A recursively defined sub-tree. :Parameters: branch_length : str The length of the branch leading to the root node of this clade. name : str The clade's name (a label). clades : list Sub-trees rooted directly under this tree's root. confidence : number Support. color : BranchColor The display color of the branch and descendents. width : number The display width of the branch and descendents. NcCs,||_||_|p g|_||_||_||_dS)z%Define parameters for the Clade tree.N)rr<r confidencecolorwidth)rwrr<rr9r:r;r r r r s    zClade.__init__cCs|S)z4Allow TreeMixin methods to traverse clades properly.r rvr r r rsz Clade.rootcCs|j S)z(Check if this is a terminal (leaf) node.rrvr r r r@ szClade.is_terminalcCs2t|ttfr |j|S|}|D]}||}q|S)z'Get clades by index (integer or slice).)rrHslicer)rwrridxr r r __getitem__&s   zClade.__getitem__cC t|jS)zAIterate through this tree's direct descendent clades (sub-trees).)iterrrvr r r rb/r"zClade.__iter__cCr?)z4Return the number of clades directly under the root.)rnrrvr r r __len__3r"z Clade.__len__cCrZ)aBoolean value of an instance of this class (True). NB: If this method is not defined, but ``__len__`` is, then the object is considered true if the result of ``__len__()`` is nonzero. We want Clade instances to always be considered True. Tr rvr r r __bool__7szClade.__bool__rhcCs4|jrt|jdkr|jdddS|jS|jjS)z"Return name of the class instance.(N%rk)r<rnrsrtrvr r r rz@s&z Clade.__str__cCrr)_colorrvr r r _get_colorGszClade._get_colorcCs|dus t|tr||_dSt|tr:|tjvr t||_dS|dr3t|dkr3t||_dSt d|t |drLt|dkrLt||_dSt d|)N#zinvalid color string rbrzinvalid color value ) r BranchColorrEr= color_names from_name startswithrnfrom_hexrRrD)rwargr r r _set_colorJs   zClade._set_colorz Branch color.)doc)NNNNNN)rtr{r|r}rr8rr@r>rbrArBr=rzrFrOr:r r r r r:s(    r:c@s*eZdZdZidddddddddd d d d d d d ddddddddddddddddddiddddd d d!d"d#d$d%dd&d'd(d)d*d+d,d+d-d.d/d0d1d2d3d4d5d6d7d8Zd9d:Zed;d<Zed=d>Zd?d@Z dAdBZ dCe fdDdEZ dCe fdFdGZ dHS)IrIaIndicates the color of a clade when rendered graphically. The color should be interpreted by client code (e.g. visualization programs) as applying to the whole clade, unless overwritten by the color(s) of sub-clades. Color values must be integers from 0 to 255. red)rrryellow)rRrRrygreen)rrgcyan)rrRrRrblue)rrrRbmagenta)rRrrRmblack)rrrkwhite)rRrRrRwmaroon)rWrrolive)rWrWrlime)rrRraquateal)rrWrWnavy)rrrWfuchsiapurple)rWrrWsilver)rkrkgray)rWrWrWgreypink)rRrksalmon)rWrorange)rRrgold)rRrtan)brown)rt*r|cCsT|||fD]}t|trd|krdksJdJdq||_||_||_dS)z"Initialize BranchColor for a tree.rrRz0Color values must be integers between 0 and 255.N)rrHrQrVrZ)rwrQrVrZr:r r r rs zBranchColor.__init__cCs\t|tr|drt|dksJd|dd|dd|ddf}|dd |DS) zConstruct a BranchColor object from a hexadecimal string. The string format is the same style used in HTML and CSS, such as '#FF8000' for an RGB value of (255, 128, 0). rGrHz.need a 24-bit hexadecimal string, e.g. #000000rrNcss |] }td|ddVqdS)0x)baseN)rH)r ccr r r r"sz'BranchColor.from_hex..)rr=rLrn)rhexstrRGBr r r rMs"zBranchColor.from_hexcCs||j|S)z3Construct a BranchColor object by the color's name.)rJ)r colornamer r r rKszBranchColor.from_namecCsd|jd|jd|jdS)aGReturn a 24-bit hexadecimal RGB representation of this color. The returned string is suitable for use in HTML/CSS, as a color parameter in matplotlib, and perhaps other situations. Examples -------- >>> bc = BranchColor(12, 200, 100) >>> bc.to_hex() '#0cc864' rG02xrQrVrZrvr r r to_hexs zBranchColor.to_hexcCs|j|j|jfS)zReturn a tuple of RGB values (0 to 255) representing this color. Examples -------- >>> bc = BranchColor(255, 165, 0) >>> bc.to_rgb() (255, 165, 0) rrvr r r to_rgbs zBranchColor.to_rgbrhcCsd|jj|j|j|jfS)z>Preserve the standard RGB order when representing this object.z%s(red=%d, green=%d, blue=%d))rsrtrQrVrZrvr r r rxs zBranchColor.__repr__cCsd|j|j|jfS)zShow the color's RGB values.z (%d, %d, %d)rrvr r r rzszBranchColor.__str__N)rtr{r|r}rJrr7rMrKrrr=rxrzr r r r rI_s       !"#$'    rI)r}rrBrcrrFr rrr,r5r9r>rOrUrYrargrr~r;r:rIr r r r s8      , S'h