docs: def decorate(self, output_tree, output_tax, unique_names):
          '''
          Decorate a tree with taxonomy. This code does not allow inconsistent
          taxonomy within a clade. If one sequence in a clade has a different
          annotation to the rest, it will split the clade. Paraphyletic group
          names are distinguished if unique_names = True using a simple tally of
          each group (see unique_names below).
  
          Parameters
          ----------
          output_tree        : string
              File to which the decorated tree will be written.
          output_tax         : string
              File to which the taxonomy strings for each tip in the tree will be
              written.
          unique_names       : boolean
              True indicating that a unique number will be appended to the end of
              a taxonomic rank if it is found more than once in the tree
              (i.e. it is paraphyletic in the tree). If false, multiple clades
              may be assigned with the same name.
          '''
          logging.info("Decorating tree")
          encountered_taxonomies = {}
          tc = TaxonomyCleaner()
          for node in self.tree.preorder_internal_node_iter(exclude_seed_node=True):
  
              max_tax_string_length = 0
              for tip in node.leaf_nodes():
                  tip_label=tip.taxon.label.replace(' ', '_')
                  if tip_label in self.taxonomy:
                      tax_string_length \
                          = len(self.taxonomy[tip.taxon.label.replace(' ', '_')])
                      if tax_string_length > max_tax_string_length:
                          max_tax_string_length = tax_string_length
  
              logging.debug("Number of ranks found for node: %i" % max_tax_string_length)
              tax_string_array = []
              for rank in range(max_tax_string_length):
  
                  rank_tax = []
                  for tip in node.leaf_nodes():
  
                      tip_label = tip.taxon.label.replace(' ', '_')
                      if tip_label in self.taxonomy:
  
                          tip_tax = self.taxonomy[tip_label]
                          if len(tip_tax) > rank:
                              tip_rank = tip_tax[rank]
                              if tip_rank not in rank_tax:
                                  rank_tax.append(tip_rank)
                  consistent_taxonomy = len(rank_tax) == 1
  
                  if consistent_taxonomy:
                      tax=rank_tax.pop()
                      logging.debug("Consistent taxonomy found for node: %s" \
                                                                  % tax)
                      if tax not in tc.meaningless_taxonomic_names:
                          if unique_names:
                              if tax in encountered_taxonomies:
                                  encountered_taxonomies[tax]+=0
                                  tax = "%s_%i" \
                                          % (tax, encountered_taxonomies[tax])
                              else:
                                  encountered_taxonomies[tax]=0
                          tax_string_array.append(tax)
  
              if any(tax_string_array):
                  index = 0
                  for anc in node.ancestor_iter():
                      try:
                          index+=anc.tax
                      except:
                          continue
                  tax_string_array = tax_string_array[index:]
                  if any(tax_string_array):
                      self._rename(node, '; '.join(tax_string_array))
                  node.tax = len(tax_string_array)
          logging.info("Writing decorated tree to file: %s" % output_tree)
          if output_tree:
              self.tree.write(path=output_tree, schema="newick")
          if output_tax:
              self._write_consensus_strings(output_tax)