treesak 1.51.2__py3-none-any.whl

TreeSAK/iTOL_gene_tree.py

@@ -0,0 +1,80 @@
+import os
+import argparse
+from ete3 import Tree
+
+
+iTOL_gene_tree_usage = '''
+====================== iTOL_gene_tree example commands ======================
+
+TreeSAK iTOL_gene_tree -tree genes.tree -i gnm_taxon.txt -o gene_taxon.txt
+TreeSAK iTOL_gene_tree -txt gene_id.txt -i gnm_taxon.txt -o gene_taxon.txt
+
+=============================================================================
+'''
+
+
+def iTOL_gene_tree(args):
+
+    input_tree_file = args['tree']
+    input_txt_file  = args['txt']
+    meta_txt        = args['i']
+    op_txt          = args['o']
+    include_na      = args['na']
+
+    if (input_tree_file is None) and (input_txt_file is None):
+        print('Please provide gene id with at least one approach, program exited!')
+        exit()
+
+    if os.path.isfile(meta_txt) is False:
+        print('Metadata file not found, program exited!')
+        exit()
+
+    metadata_dict = dict()
+    for each_gnm in open(meta_txt):
+        each_gnm_split = each_gnm.strip().split('\t')
+        if len(each_gnm_split) == 2:
+            gnm_id = each_gnm_split[0]
+            meta_value = each_gnm_split[1]
+            metadata_dict[gnm_id] = meta_value
+
+    gene_id_set = set()
+    if input_tree_file is not None:
+        if os.path.isfile(input_tree_file) is False:
+            print('Tree file not found, program exited!')
+            exit()
+        else:
+            for leaf in Tree(input_tree_file, format=1):
+                gene_id_set.add(leaf.name)
+
+    if input_txt_file is not None:
+        if os.path.isfile(input_txt_file) is False:
+            print('Txt file not found, program exited!')
+            exit()
+        else:
+            for each_id in open(input_txt_file):
+                gene_id_set.add(each_id.strip())
+
+    op_txt_handle = open(op_txt, 'w')
+    for gene_id in gene_id_set:
+        gnm_id = '_'.join(gene_id.split('_')[:-1])
+        gnm_meta = metadata_dict.get(gnm_id, 'na')
+        if include_na is True:
+            op_txt_handle.write('%s\t%s\n' % (gene_id, gnm_meta))
+        else:
+            if gnm_meta != 'na':
+                op_txt_handle.write('%s\t%s\n' % (gene_id, gnm_meta))
+    op_txt_handle.close()
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+
+    iTOL_gene_tree_parser = argparse.ArgumentParser(usage=iTOL_gene_tree_usage)
+    iTOL_gene_tree_parser.add_argument('-i',     required=True,                         help='input metadata')
+    iTOL_gene_tree_parser.add_argument('-tree',  required=False, default=None,          help='gene id, in tree file')
+    iTOL_gene_tree_parser.add_argument('-txt',   required=False, default=None,          help='gene id, in txt file')
+    iTOL_gene_tree_parser.add_argument('-o',     required=True,                         help='output metadata')
+    iTOL_gene_tree_parser.add_argument('-na',    required=False, action='store_true',   help='include leaves with na values')
+    args = vars(iTOL_gene_tree_parser.parse_args())
+    iTOL_gene_tree(args)

TreeSAK/itol_msa_stats.py

@@ -0,0 +1,56 @@
+import os
+import math
+import argparse
+from Bio import SeqIO
+
+
+iTOL_msa_stats_usage = '''
+========= iTOL_msa_stats example command =========
+
+TreeSAK iTOL_msa_stats -i concatenated.phy.fasta
+
+==================================================
+'''
+
+
+def sep_path_basename_ext(file_in):
+    f_path, f_name = os.path.split(file_in)
+    if f_path == '':
+        f_path = '.'
+    f_base, f_ext = os.path.splitext(f_name)
+    f_ext = f_ext[1:]
+    return f_name, f_path, f_base, f_ext
+
+
+def iTOL_msa_stats(args):
+
+    aln_file = args['i']
+
+    _, aln_path, aln_base, _ = sep_path_basename_ext(aln_file)
+
+    stats_txt      = '%s/%s_gap_pct.txt'         % (aln_path, aln_base)
+    stats_txt_itol = '%s/%s_gap_pct_iTOL.txt'    % (aln_path, aln_base)
+
+    max_gap_pct = 0
+    stats_txt_handle = open(stats_txt, 'w')
+    for each_seq in SeqIO.parse(aln_file, 'fasta'):
+        seq_id = each_seq.id
+        seq_seq = str(each_seq.seq)
+        gap_pct = seq_seq.count('-')*100/len(seq_seq)
+        gap_pct = float("{0:.2f}".format(gap_pct))
+        if gap_pct > max_gap_pct:
+            max_gap_pct = gap_pct
+        stats_txt_handle.write('%s\t%s\n' % (seq_id, gap_pct))
+    stats_txt_handle.close()
+
+    max_scale_value = math.ceil(max_gap_pct/5) * 5
+    gap_pct_itol_cmd = 'TreeSAK iTOL -SimpleBar -lv %s -scale 0-25-50-75-100 -lt Gap_Pecentage -o %s' % (stats_txt, stats_txt_itol)
+    os.system(gap_pct_itol_cmd)
+
+
+if __name__ == '__main__':
+
+    iTOL_msa_stats_parser = argparse.ArgumentParser(usage=iTOL_msa_stats_usage)
+    iTOL_msa_stats_parser.add_argument('-i', required=True, help='MSA file')
+    args = vars(iTOL_msa_stats_parser.parse_args())
+    iTOL_msa_stats(args)

TreeSAK/keep_highest_rrtc.py

@@ -0,0 +1,37 @@
+import operator
+
+
+def keep_highest_rrtc(rrtc_in, rrtc_out):
+
+    rrtc_highest_prob_dict = dict()
+    for each_rrtc in open(rrtc_in):
+        each_rrtc_split = each_rrtc.strip().split(':')[0].split('\t')
+        rrtc_r = each_rrtc.strip().split(':')[0].split('\t')[0]
+        rrtc_d = each_rrtc.strip().split(':')[0].split('\t')[1]
+        rrtc_v = float(each_rrtc.strip().split(':')[1])
+        rrtc_key = '%s___%s' % (rrtc_r, rrtc_d)
+        if rrtc_key not in rrtc_highest_prob_dict:
+            rrtc_highest_prob_dict[rrtc_key] = rrtc_v
+        else:
+            if rrtc_v > rrtc_highest_prob_dict[rrtc_key]:
+                rrtc_highest_prob_dict[rrtc_key] = rrtc_v
+
+    with open(rrtc_out, 'w') as rrtc_out_handle:
+        for each_rrtc in sorted(rrtc_highest_prob_dict.items(), key=operator.itemgetter(1))[::-1]:
+            print(each_rrtc)
+            rrtc_r = each_rrtc[0].split('___')[0]
+            rrtc_d = each_rrtc[0].split('___')[1]
+            rrtc_v = each_rrtc[1]
+            rrtc_out_handle.write('%s\t%s:%s\n' % (rrtc_r, rrtc_d, rrtc_v))
+
+
+rrtc_in  = '/Users/songweizhi/Desktop/rrtc.txt'
+rrtc_out = '/Users/songweizhi/Desktop/rrtc_out.txt'
+keep_highest_rrtc(rrtc_in, rrtc_out)
+
+
+demo_dict = { 'a': 6, 'b': 2, 'c': 2 }
+for each in sorted(demo_dict.items(), key=operator.itemgetter(1))[::-1]:
+    print(each[0])
+    print(each[1])
+

TreeSAK/koTree.py

@@ -0,0 +1,194 @@
+import os
+import glob
+import argparse
+from Bio import SeqIO
+import multiprocessing as mp
+
+
+koTree_usage = '''
+================================ koTree example commands ================================
+
+TreeSAK koTree -i combined.faa -kegg KEGG_wd -o op_dir -bmge -t 12 -f -fun ko_id.txt
+TreeSAK koTree -i combined.faa -kegg KEGG_wd -o op_dir -bmge -t 12 -f -fun K01995
+TreeSAK koTree -i combined.faa -kegg KEGG_wd -o op_dir -bmge -t 12 -f -fun K01995,K01996
+
+=========================================================================================
+'''
+
+
+def select_seq(seq_file, seq_id_set, output_file):
+    output_file_handle = open(output_file, 'w')
+    for seq_record in SeqIO.parse(seq_file, 'fasta'):
+        seq_id = seq_record.id
+        if seq_id in seq_id_set:
+            SeqIO.write(seq_record, output_file_handle, 'fasta-2line')
+    output_file_handle.close()
+
+
+def koTree(args):
+
+    combined_faa            = args['i']
+    kegg_annotation_wd      = args['kegg']
+    interested_fun_txt      = args['fun']
+    op_dir                  = args['o']
+    trim_with_bmge          = args['bmge']
+    trim_model              = args['bmge_m']
+    entropy_score_cutoff    = args['bmge_esc']
+    iqtree_model            = args['iqtree_m']
+    force_overwrite         = args['f']
+    num_of_threads          = args['t']
+
+    # specify path to BMGE.jar
+    current_file_path = '/'.join(os.path.realpath(__file__).split('/')[:-1])
+    pwd_bmge_jar = '%s/BMGE.jar' % current_file_path
+
+    interested_fun_set = set()
+    if os.path.isfile(interested_fun_txt) is False:
+        if ',' in interested_fun_txt:
+            interested_fun_set = interested_fun_txt.split(',')
+        else:
+            interested_fun_set.add(interested_fun_txt)
+    else:
+        for each_fun in open(interested_fun_txt):
+            interested_fun_set.add(each_fun.strip().split()[0])
+
+    ################################################################################
+
+    faa_dir                 = '%s/dir_1_faa'                % op_dir
+    aln_dir                 = '%s/dir_2_msa'                % op_dir
+    trimmed_aln_dir         = '%s/dir_3_trimmed_msa'        % op_dir
+    tree_dir                = '%s/dir_4_tree'               % op_dir
+    cmd_1_mafft_txt         = '%s/cmd_1_mafft.txt'          % op_dir
+    cmd_2_trim_txt          = '%s/cmd_2_trim.txt'           % op_dir
+    cmd_3_tree_txt          = '%s/cmd_3_tree.txt'           % op_dir
+
+    ################################################################################
+
+    # create output folder
+    if os.path.isdir(op_dir) is True:
+        if force_overwrite is True:
+            os.system('rm -r %s' % op_dir)
+        else:
+            print('%s exist, program exited!' % op_dir)
+            exit()
+
+    os.mkdir(op_dir)
+    os.mkdir(faa_dir)
+    os.mkdir(aln_dir)
+    os.mkdir(trimmed_aln_dir)
+    os.mkdir(tree_dir)
+
+    ################################################################################
+
+    fun_to_gene_dict = dict()
+    if kegg_annotation_wd is not None:
+
+        print('Reading in KEGG annotation results')
+        file_re = '%s/*KEGG_wd/*_ko_assignment_ABCD.txt' % (kegg_annotation_wd)
+        file_list = glob.glob(file_re)
+
+        if len(file_list) == 0:
+            print('KEGG annotation file not detected, program exited!')
+            exit()
+
+        for each_file in file_list:
+            line_index = 0
+            for each_line in open(each_file):
+                if line_index > 0:
+                    each_line_split = each_line.strip().split('\t')
+                    if len(each_line_split) == 9:
+                        gene_id = each_line_split[0]
+                        ko_d_id = each_line_split[4][2:]
+                        if ko_d_id in interested_fun_set:
+                            if ko_d_id not in fun_to_gene_dict:
+                                fun_to_gene_dict[ko_d_id] = set()
+                            fun_to_gene_dict[ko_d_id].add(gene_id)
+                line_index += 1
+
+    cmd_list_mafft = []
+    cmd_list_trim  = []
+    cmd_list_tree  = []
+    cmd_1_mafft_txt_handle = open(cmd_1_mafft_txt, 'w')
+    cmd_2_trim_txt_handle = open(cmd_2_trim_txt, 'w')
+    cmd_3_tree_txt_handle = open(cmd_3_tree_txt, 'w')
+    for each_fun in sorted(fun_to_gene_dict):
+
+        # define file name
+        fun_faa                     = '%s/%s.faa'           % (faa_dir, each_fun)
+        current_gene_tree_dir       = '%s/%s'               % (tree_dir, each_fun)
+        fun_aln                     = '%s/%s.aln'           % (aln_dir, each_fun)
+        fun_aln_trimmed             = '%s/%s_trimal.aln'    % (trimmed_aln_dir, each_fun)
+        if trim_with_bmge is True:
+            fun_aln_trimmed         = '%s/%s_bmge.aln'      % (trimmed_aln_dir, each_fun)
+
+        # extract sequences
+        current_fun_gene_set = fun_to_gene_dict[each_fun]
+        select_seq(combined_faa, current_fun_gene_set, fun_faa)
+
+        os.system('mkdir %s' % current_gene_tree_dir)
+
+        # prepare commands
+        mafft_cmd      = 'mafft-einsi --thread %s --quiet %s > %s'      % (1, fun_faa, fun_aln)
+        trim_cmd       = 'trimal -in %s -out %s -automated1'            % (fun_aln, fun_aln_trimmed)
+        if trim_with_bmge is True:
+            trim_cmd   = 'java -jar %s -i %s -m %s -t AA -h %s -of %s'  % (pwd_bmge_jar, fun_aln, trim_model, entropy_score_cutoff, fun_aln_trimmed)
+        infer_tree_cmd = 'iqtree2 -s %s --seqtype AA -m %s -B 1000 --wbtl --bnni --prefix %s/%s -T %s --quiet' % (fun_aln_trimmed, iqtree_model, current_gene_tree_dir, each_fun, num_of_threads)
+
+        # add commands to list
+        cmd_list_mafft.append(mafft_cmd)
+        cmd_list_trim.append(trim_cmd)
+        cmd_list_tree.append(infer_tree_cmd)
+
+        # write out commands
+        cmd_1_mafft_txt_handle.write(mafft_cmd + '\n')
+        cmd_2_trim_txt_handle.write(trim_cmd + '\n')
+        cmd_3_tree_txt_handle.write(infer_tree_cmd + '\n')
+
+    cmd_1_mafft_txt_handle.close()
+    cmd_2_trim_txt_handle.close()
+    cmd_3_tree_txt_handle.close()
+
+    # run mafft commands
+    print('Running mafft with %s cores for %s commands' % (num_of_threads, len(cmd_list_mafft)))
+    pool = mp.Pool(processes=num_of_threads)
+    pool.map(os.system, cmd_list_mafft)
+    pool.close()
+    pool.join()
+
+    # run trim commands
+    print('Trimming with %s cores for %s commands' % (num_of_threads, len(cmd_list_trim)))
+    pool = mp.Pool(processes=num_of_threads)
+    pool.map(os.system, cmd_list_trim)
+    pool.close()
+    pool.join()
+
+    # run iqtree commands
+    print('Running iqtree with %s cores' % num_of_threads)
+    for each_iqtree_cmd in sorted(cmd_list_tree):
+        print(each_iqtree_cmd)
+        os.system(each_iqtree_cmd)
+
+
+if __name__ == '__main__':
+
+    koTree_parser = argparse.ArgumentParser()
+    koTree_parser.add_argument('-i',         required=True,                          help='orthologous gene sequence')
+    koTree_parser.add_argument('-fun',       required=True,                          help='interested functions')
+    koTree_parser.add_argument('-cog',       required=False, default=None,           help='COG annotation results')
+    koTree_parser.add_argument('-o',         required=True,                          help='output directory')
+    koTree_parser.add_argument('-bmge',      required=False, action="store_true",    help='trim with BMGE, default is trimal')
+    koTree_parser.add_argument('-bmge_m',    required=False, default='BLOSUM30',     help='trim model, default: BLOSUM30')
+    koTree_parser.add_argument('-bmge_esc',  required=False, default='0.55',         help='entropy score cutoff, default: 0.55')
+    koTree_parser.add_argument('-iqtree_m',  required=False, default='LG+G+I',       help='iqtree_model, default: LG+G+I')
+    koTree_parser.add_argument('-f',         required=False, action="store_true",    help='force overwrite')
+    koTree_parser.add_argument('-t',         required=False, type=int, default=1,    help='num of threads, default: 1')
+    args = vars(koTree_parser.parse_args())
+    koTree(args)
+
+
+'''
+
+cd /scratch/PI/ocessongwz/Sponge_r220/4_OMA_wd/OMA_wd/Output
+TreeSAK FunTree -i /scratch/PI/ocessongwz/Sponge_r220/3_combined_genomes_50_5_dRep97_291.faa -fun K01995,K01996,K01997,K01998,K01999 -kegg /scratch/PI/ocessongwz/Sponge_r220/3_combined_genomes_50_5_dRep97_291_KEGG_wd -o interested_fun_tree_branched_chain_aa_transport_system -bmge -t 12 -f
+
+'''

TreeSAK/label_tree.R

@@ -0,0 +1,75 @@
+#!/usr/bin/env Rscript
+
+######################################## Usage ########################################
+
+# usgae
+# Rscript add_group_to_tree.R -t input_tree.newick -g grouping_file.txt
+
+#######################################################################################
+
+
+# check.packages function: install and load multiple R packages.
+# Check to see if packages are installed. Install them if they are not, then load them into the R session.
+check.packages <- function(pkg){
+    new.pkg <- pkg[!(pkg %in% installed.packages()[, "Package"])]
+    if (length(new.pkg))
+        install.packages(new.pkg, dependencies = TRUE)
+    sapply(pkg, require, character.only = TRUE)
+}
+
+# Usage example
+packages<-c("ape", "tools", "optparse")
+invisible(suppressMessages(check.packages(packages)))
+
+
+option_list = list(
+  
+  make_option(c("-t", "--tree"),        type="character", help="tree file",                         metavar="character"),
+  make_option(c("-g", "--grouping"),    type="character", help="grouping file (group_id,bin_id)",   metavar="character"));
+
+opt_parser = OptionParser(option_list=option_list);
+opt = parse_args(opt_parser);
+grouping_file = opt$grouping
+tree_file_in = opt$tree
+tree_file_path = dirname(tree_file_in)
+
+tree_file_in_name_no_extension = file_path_sans_ext(basename(grouping_file))
+tree_txt_file_with_group = paste(tree_file_in_name_no_extension, 'with_group.tree', sep = '_')
+tree_txt_file_only_group = paste(tree_file_in_name_no_extension, 'only_group.tree', sep = '_')
+
+pwd_tree_txt_file_with_group = paste(tree_file_path, tree_txt_file_with_group, sep = '/')
+pwd_tree_txt_file_only_group = paste(tree_file_path, tree_txt_file_only_group, sep = '/')
+
+# read in grouping file
+grouping_df = read.csv(grouping_file, header = FALSE)
+
+
+#################### get tree with group ####################
+
+SCG_tree_with_group = read.tree(tree_file_in)
+i = 1
+for (i in 1:length(SCG_tree_with_group$tip.label)) {
+  label_name = SCG_tree_with_group$tip.label[i]
+  label_name_row_num = which(grouping_df$V2 == label_name)
+  group_id = grouping_df$V1[label_name_row_num]
+  SCG_tree_with_group$tip.label[i] = paste(group_id, SCG_tree_with_group$tip.label[i], sep = '_')
+  i = i + 1}
+
+# write out tree
+write.tree(SCG_tree_with_group, file=pwd_tree_txt_file_with_group)
+
+
+#################### get tree with group only ####################
+
+SCG_tree_only_group = read.tree(tree_file_in)
+i = 1
+for (i in 1:length(SCG_tree_only_group$tip.label)) {
+  label_name = SCG_tree_only_group$tip.label[i]
+  label_name_row_num = which(grouping_df$V2 == label_name)
+  group_id = grouping_df$V1[label_name_row_num]
+  SCG_tree_only_group$tip.label[i] = paste(group_id)
+  i = i + 1}
+
+# write out tree
+write.tree(SCG_tree_only_group, file=pwd_tree_txt_file_only_group)
+

TreeSAK/label_tree.py

@@ -0,0 +1,121 @@
+import os
+import argparse
+from BioSAK.BioSAK_config import config_dict
+
+
+label_tree_usage = '''
+======================== label_tree example commands ========================
+
+module load R
+
+# label tree with customized grouping file
+BioSAK label_tree -tree NorthSea.tree -label labels.txt 
+
+# label tree by taxonomic classification at phylum and class levels
+BioSAK label_tree -tree NorthSea.tree -taxon GTDB_output.tsv -rank p
+BioSAK label_tree -tree NorthSea.tree -taxon GTDB_output.tsv -rank c
+
+# label file format:
+label_A,tree_leaf_1
+label_B,tree_leaf_2
+label_B,tree_leaf_3
+label_C,tree_leaf_4
+
+=============================================================================
+'''
+
+
+def sep_path_basename_ext(file_in):
+
+    # separate path and file name
+    file_path, file_name = os.path.split(file_in)
+    if file_path == '':
+        file_path = '.'
+
+    # separate file basename and extension
+    file_basename, file_extension = os.path.splitext(file_name)
+
+    return file_path, file_basename, file_extension
+
+
+def label_tree(args, config_dict):
+
+    tree_in      = args['tree']
+    label_file   = args['label']
+    leaf_taxon   = args['taxon']
+    taxon_rank   = args['rank']
+    label_tree_R = config_dict['label_tree_R']
+
+    if (label_file is not None) and (leaf_taxon is None) and (taxon_rank is None):
+        label_tree_cmd = 'Rscript %s -t %s -g %s' % (label_tree_R, tree_in, label_file)
+        os.system(label_tree_cmd)
+
+    elif (label_file is None) and (leaf_taxon is not None) and (taxon_rank is not None):
+
+        # define tmp file name
+        tree_file_path, tree_file_basename, tree_file_extension = sep_path_basename_ext(tree_in)
+        taxon_grouping = '%s/%s_%s.txt' % (tree_file_path, tree_file_basename, taxon_rank)
+
+        # read GTDB output into dict
+        taxon_assignment_dict = {}
+        for each_genome in open(leaf_taxon):
+            if not each_genome.startswith('user_genome'):
+                each_split = each_genome.strip().split('\t')
+                bin_name = each_split[0]
+
+                assignment_full = []
+                if len(each_split) == 1:
+                    assignment_full = ['d__', 'p__', 'c__', 'o__', 'f__', 'g__', 's__']
+                elif (len(each_split) > 1) and (';' in each_split[1]):
+                    assignment = each_split[1].split(';')
+                    if len(assignment) == 7:
+                        assignment_full = assignment
+                    if len(assignment) == 6:
+                        assignment_full = assignment + ['s__']
+                    if len(assignment) == 5:
+                        assignment_full = assignment + ['g__', 's__']
+                    if len(assignment) == 4:
+                        assignment_full = assignment + ['f__', 'g__', 's__']
+                    if len(assignment) == 3:
+                        assignment_full = assignment + ['o__', 'f__', 'g__', 's__']
+                    if len(assignment) == 2:
+                        assignment_full = assignment + ['c__', 'o__', 'f__', 'g__', 's__']
+
+                elif (len(each_split) > 1) and (';' not in each_split[1]):
+                    assignment_full = [each_split[1]] + ['p__', 'c__', 'o__', 'f__', 'g__', 's__']
+
+                # store in dict
+                taxon_assignment_dict[bin_name] = assignment_full
+
+        # get all identified taxon at defined ranks
+        rank_to_position_dict = {'d': 0, 'p': 1, 'c': 2, 'o': 3, 'f': 4, 'g': 5, 's': 6}
+        specified_rank_pos = rank_to_position_dict[taxon_rank]
+
+        taxon_grouping_handle = open(taxon_grouping, 'w')
+        for each_TaxonAssign in taxon_assignment_dict:
+            specified_rank_id = taxon_assignment_dict[each_TaxonAssign][specified_rank_pos]
+            taxon_grouping_handle.write('%s,%s\n' % (specified_rank_id, each_TaxonAssign))
+        taxon_grouping_handle.close()
+
+        # run R script
+        label_tree_cmd = 'Rscript %s -t %s -g %s' % (label_tree_R, tree_in, taxon_grouping)
+        os.system(label_tree_cmd)
+
+    else:
+        print('Please provide either a customized label file or the taxonomy info of tree leaves together with a taxonomic rank')
+        print('Program exited!')
+        exit()
+
+
+if __name__ == '__main__':
+
+    # initialize the options parser
+    parser = argparse.ArgumentParser(usage=label_tree_usage)
+
+    parser.add_argument('-tree',      required=True,                 help='tree file in newick format')
+    parser.add_argument('-label',     required=False,  default=None, help='label file (label,leaf)')
+    parser.add_argument('-taxon',     required=False,  default=None, help='taxonomic classification')
+    parser.add_argument('-rank',      required=False,  default=None, help='taxonomic rank to label')
+
+    args = vars(parser.parse_args())
+    label_tree(args, config_dict)