treesak 1.53.3__py3-none-any.whl

TreeSAK/assessOG.py

@@ -0,0 +1,45 @@
+import os
+import glob
+from Bio import SeqIO
+
+
+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)
+
+    return f_name, f_path, f_base, f_ext[1:]
+
+
+def get_gnm_og_cov(og_dir, og_ext, og_cov_txt):
+
+    og_file_re   = '%s/*.%s' % (og_dir, og_ext)
+    og_file_list = glob.glob(og_file_re)
+
+    gnm_to_og_dict = dict()
+    for og_file in og_file_list:
+        _, _, og_id, _ = sep_path_basename_ext(og_file)
+        for each_seq in SeqIO.parse(og_file, 'fasta'):
+            seq_id = each_seq.id
+            gnm_id = '_'.join(seq_id.split('_')[:-1])
+            if gnm_id not in gnm_to_og_dict:
+                gnm_to_og_dict[gnm_id] = set()
+            gnm_to_og_dict[gnm_id].add(og_id)
+
+    og_cov_txt_handle = open(og_cov_txt, 'w')
+    for each_gnm in sorted(list(gnm_to_og_dict.keys())):
+        gnm_og_set = gnm_to_og_dict[each_gnm]
+        og_cov = len(gnm_og_set)*100/len(og_file_list)
+        og_cov = float("{0:.2f}".format(og_cov))
+        og_cov_txt_handle.write('%s\t%s\n' % (each_gnm, og_cov))
+    og_cov_txt_handle.close()
+
+
+og_dir      = '/Users/songweizhi/Desktop/OrthologousGroupsFasta_cov95'
+og_ext      = 'fa'
+og_cov_txt  = '/Users/songweizhi/Desktop/gnm_og_cov.txt'
+
+get_gnm_og_cov(og_dir, og_ext, og_cov_txt)
+

TreeSAK/batch_itol.py

@@ -0,0 +1,171 @@
+import os
+import glob
+import argparse
+from pathlib import Path
+from itolapi import Itol
+
+
+batch_itol_usage = '''
+======================================= batch_itol example commands =======================================
+
+TreeSAK batch_itol -f -api API_key -ip batch_access_tmp -a annotation_files.txt -i input.tree -o out.pdf
+TreeSAK batch_itol -f -api API_key -ip batch_access_tmp -a annotation_files.txt -i tree_dir -x tree -o out_pdf
+
+Manual
+https://github.com/albertyw/itolapi
+http://itol.embl.de/help.cgi#batch
+
+# An example of the parameter file is available here
+# to be added
+
+===========================================================================================================
+'''
+
+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_single_tree(tree_file, annotation_files_txt, project_name, APIkey, parameter_dict, op_plot):
+
+    annotation_file_list = []
+    for each_file in open(annotation_files_txt):
+        annotation_file_list.append(each_file.strip())
+
+    op_plot_ext = op_plot.split('.')[-1]
+
+    # upload tree to iTOL
+    itol_uploader = Itol()
+    itol_uploader.params['projectName'] = project_name  # better to create a project with a unique name.
+    itol_uploader.params['APIkey']      = APIkey  # sine we are the same account, we can use the same APIkey
+    itol_uploader.params['treeName']    = tree_file
+    itol_uploader.add_file(Path(tree_file))
+
+    # upload annotation files to iTOL
+    for annotation_file in annotation_file_list:
+        itol_uploader.add_file(Path(annotation_file))
+
+    status = itol_uploader.upload()
+    # import pdb;pdb.set_trace()
+    assert status != False
+
+    # the following parameters are optional, refer to https://itol.embl.de/help.cgi#batchExp
+    if len(annotation_file_list) == 1:
+        datasets_visible_str = '0'
+    elif len(annotation_file_list) == 2:
+        datasets_visible_str = '0,1'
+    elif len(annotation_file_list) == 3:
+        datasets_visible_str = '0,1,2'
+    else:
+        datasets_visible_str = ','.join([str(i) for i in list(range(0, len(annotation_file_list)))])
+
+    parameter_dict.get('', 'to be added')
+    parameter_dict.get('', '')
+
+
+    # for a full list of options, go to https://itol.embl.de/help.cgi#batchExp
+    itol_exporter = itol_uploader.get_itol_export()
+    itol_exporter.set_export_param_value('internal_scale', parameter_dict.get('internal_scale', '0'))
+    itol_exporter.set_export_param_value('datasets_visible', datasets_visible_str)
+    itol_exporter.set_export_param_value('display_mode', parameter_dict.get('display_mode', '1'))
+    itol_exporter.set_export_param_value('vertical_shift_factor', parameter_dict.get('vertical_shift_factor', '1'))
+    itol_exporter.set_export_param_value('horizontal_scale_factor', parameter_dict.get('horizontal_scale_factor', '0.9'))
+
+    # range
+    itol_exporter.set_export_param_value('range_mode', parameter_dict.get('range_mode', '2'))                                           # Possible values: 0,1 or 2 (0=off, 1=cover labels only, 2=cover full clades)
+    itol_exporter.set_export_param_value('include_ranges_legend', parameter_dict.get('include_ranges_legend', '0'))
+
+    # label
+    # itol_exporter.set_export_param_value('current_font_size', '12') # the default looks good
+    itol_exporter.set_export_param_value('current_font_name', parameter_dict.get('current_font_name', 'Courier'))
+    itol_exporter.set_export_param_value('default_label_color', parameter_dict.get('default_label_color', '#000000'))
+
+    # branch
+    itol_exporter.set_export_param_value('line_width', parameter_dict.get('line_width', '2'))
+    itol_exporter.set_export_param_value('dashed_lines', parameter_dict.get('dashed_lines', '1'))
+    itol_exporter.set_export_param_value('default_branch_color', parameter_dict.get('default_branch_color', '#000000'))
+
+    # bootstrap
+    itol_exporter.set_export_param_value('metadata_source', parameter_dict.get('metadata_source', 'bootstrap'))                         # Which metadata source to use for bootstrap display options
+    itol_exporter.set_export_param_value('bootstrap_display', parameter_dict.get('bootstrap_display', '1'))                             # possible values: 0 or 1
+    itol_exporter.set_export_param_value('bootstrap_type', parameter_dict.get('bootstrap_type', '2'))                                   # Possible values: 1, 2, 3 or 4 (1=Symbol, 2=Text label, 3=Branch color and 4=Branch width)
+    itol_exporter.set_export_param_value('bootstrap_label_size', parameter_dict.get('bootstrap_label_size', '15'))                      # in pixels, integer >= 9
+    itol_exporter.set_export_param_value('bootstrap_label_percent_factor', parameter_dict.get('bootstrap_label_percent_factor', '10'))  # in pixels, integer >= 9
+
+    # write out
+    itol_exporter.set_export_param_value('format', op_plot_ext)
+    itol_exporter.export(op_plot)
+
+
+def batch_itol(args):
+
+    tree_file_dir           = args['i']
+    tree_file_ext           = args['x']
+    annotation_files_txt    = args['a']
+    op_file_dir             = args['o']
+    force_overwrite         = args['f']
+    API_key                 = args['api']
+    project_name            = args['ip']
+    para_txt                = args['para']
+
+    para_dict = dict()
+    if para_txt is not None:
+        if os.path.isfile(tree_file_dir) is False:
+            print('The specified parameter file does not exist, program exited!')
+            exit()
+        else:
+            for each_line in open(para_txt):
+                if not each_line.startswith('#'):
+                    if len(each_line.strip()) > 0:
+                        para_without_comment = each_line.strip().split('#')[0].strip()
+                        para_without_comment_split = para_without_comment.split('\t')
+                        para_dict[para_without_comment_split[0]] = para_without_comment_split[1]
+
+    if os.path.isfile(tree_file_dir) is True:
+        itol_single_tree(tree_file_dir, annotation_files_txt, project_name, API_key, para_dict, op_file_dir)
+    elif os.path.isdir(tree_file_dir) is True:
+        file_re = '%s/*.%s' % (tree_file_dir, tree_file_ext)
+        file_list = glob.glob(file_re)
+
+        if len(file_list) == 0:
+            print('no file found in %s, please check file extension, program exited!' % tree_file_dir)
+            exit()
+
+        # create output folder
+        if os.path.isdir(op_file_dir) is True:
+            if force_overwrite is True:
+                os.system('rm -r %s' % op_file_dir)
+            else:
+                print('Output folder detected, program exited!')
+                exit()
+        os.system('mkdir %s' % op_file_dir)
+
+        for each_file in file_list:
+            f_name, f_path, f_base, f_ext = sep_path_basename_ext(each_file)
+            op_pdf = '%s/%s.pdf' % (op_file_dir, f_base)
+
+            itol_single_tree(each_file, annotation_files_txt, project_name, API_key, para_dict, op_pdf)
+    else:
+        print('please provide input file with -i, program exited!')
+        exit()
+
+
+if __name__ == '__main__':
+
+    batch_itol_parser = argparse.ArgumentParser(usage=batch_itol_usage)
+    batch_itol_parser.add_argument('-i',        required=True,                              help='input tree file or folder')
+    batch_itol_parser.add_argument('-x',        required=False, default=None,               help='file extension')
+    batch_itol_parser.add_argument('-o',        required=True,                              help='output file or folder')
+    batch_itol_parser.add_argument('-a',        required=False, default=None,               help='a txt file contain absolute to all annotation files')
+    batch_itol_parser.add_argument('-para',     required=False, default=None,               help='parameter file')
+    batch_itol_parser.add_argument('-api',      required=True,                              help='iTOL API key')
+    batch_itol_parser.add_argument('-ip',       required=False, default='batch_access_tmp', help='iTOL project name, default: batch_access_tmp')
+    batch_itol_parser.add_argument('-f',        required=False, action="store_true",        help='force overwrite')
+    args = vars(batch_itol_parser.parse_args())
+    batch_itol(args)

TreeSAK/catfasta2phy.py

@@ -0,0 +1,140 @@
+import os
+import glob
+from Bio import SeqIO
+from Bio import AlignIO
+
+
+def catfasta2phy(msa_dir, msa_ext, concatenated_msa_phy, partition_file):
+
+    concatenated_msa_fasta = '%s.fasta' % concatenated_msa_phy
+    msa_file_re            = '%s/*.%s'  % (msa_dir, msa_ext)
+    msa_file_list          = [os.path.basename(file_name) for file_name in glob.glob(msa_file_re)]
+    msa_file_list_sorted   = sorted(msa_file_list)
+
+    complete_gnm_set = set()
+    for each_msa_file in msa_file_list:
+        pwd_msa = '%s/%s' % (msa_dir, each_msa_file)
+        for each_seq in SeqIO.parse(pwd_msa, 'fasta'):
+            complete_gnm_set.add(each_seq.id)
+
+    complete_gnm_list_sorted = sorted([i for i in complete_gnm_set])
+
+    # initialize concatenated msa dict
+    gnm_to_seq_dict = {i: '' for i in complete_gnm_list_sorted}
+    msa_len_dict = dict()
+    for each_msa_file in msa_file_list_sorted:
+        gene_id = each_msa_file.split('.' + msa_ext)[0]
+
+        # read in msa
+        current_msa_len = 0
+        current_msa_len_set = set()
+        pwd_current_msa = '%s/%s' % (msa_dir, each_msa_file)
+        current_msa_seq_dict = dict()
+        for each_seq in SeqIO.parse(pwd_current_msa, 'fasta'):
+            complete_gnm_set.add(each_seq.id)
+            current_msa_seq_dict[each_seq.id] = str(each_seq.seq)
+            current_msa_len_set.add(len(each_seq.seq))
+            current_msa_len = len(each_seq.seq)
+
+        if len(current_msa_len_set) != 1:
+            print('Sequences with different length were found in %s, program exited!' % each_msa_file)
+            exit()
+
+        msa_len_dict[gene_id] = current_msa_len
+
+        # add sequence to concatenated msa dict
+        for each_gnm in complete_gnm_list_sorted:
+            msa_seq = current_msa_seq_dict.get(each_gnm, current_msa_len*'-')
+            gnm_to_seq_dict[each_gnm] += msa_seq
+
+    # write out concatenated msa
+    concatenated_msa_handle = open(concatenated_msa_fasta, 'w')
+    for each_gnm in complete_gnm_list_sorted:
+        concatenated_msa_handle.write('>%s\n' % each_gnm)
+        concatenated_msa_handle.write('%s\n' % gnm_to_seq_dict[each_gnm])
+    concatenated_msa_handle.close()
+
+    # write out partition file
+    end_pos = 0
+    partition_file_handle = open(partition_file, 'w')
+    for each_m in msa_file_list_sorted:
+        gene_id = each_m.split('.' + msa_ext)[0]
+        current_m_len = msa_len_dict[gene_id]
+        partition_file_handle.write('%s = %s-%s\n' % (each_m, (end_pos + 1), (end_pos + current_m_len)))
+        end_pos += current_m_len
+    partition_file_handle.close()
+
+    # convert msa in fasta to phy
+    AlignIO.convert(concatenated_msa_fasta, 'fasta', concatenated_msa_phy, 'phylip-relaxed')
+
+
+msa_dir                = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed'
+msa_ext                = 'aln'
+concatenated_msa_phy   = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed_concatenated.phy'
+partition_file         = '/Users/songweizhi/Desktop/s06_identified_marker_aln_trimmed_concatenated_partition.txt'
+# catfasta2phy(msa_dir, msa_ext, concatenated_msa_phy, partition_file)
+
+
+
+msa_file = '/Users/songweizhi/Desktop/PA_75_DeltaLL_75_concatenated.phy'
+msa_file_subset = '/Users/songweizhi/Desktop/PA_75_DeltaLL_75_concatenated_subset.phy'
+
+from Bio import AlignIO
+
+def slice_msa_by_col(msa_in, range_str, msa_out):
+    alignment = AlignIO.read(msa_in, 'phylip-relaxed')
+
+    range_l = int(range_str.split('-')[0]) - 1
+    range_r = int(range_str.split('-')[1])
+
+    aln_subset = alignment[:, range_l:range_r]
+    AlignIO.write(aln_subset, msa_out, 'phylip-relaxed')
+
+
+def slice_msa_by_col_manual(msa_in, range_str, msa_out):
+    alignment = AlignIO.read(msa_in, 'phylip-relaxed')
+
+    range_l = int(range_str.split('-')[0]) - 1
+    range_r = int(range_str.split('-')[1])
+    aln_subset = alignment[:, range_l:range_r]
+
+    max_seq_id_len = 0
+    for each_seq in aln_subset:
+        seq_id_len = len(each_seq.id)
+        if seq_id_len > max_seq_id_len:
+            max_seq_id_len = seq_id_len
+    print(max_seq_id_len)
+
+    with open(msa_out, 'w') as msa_out_handle:
+        msa_out_handle.write('%s %s\n' % (len(aln_subset), aln_subset.get_alignment_length()))
+        for each_seq in aln_subset:
+            seq_id = each_seq.id
+            seq_id_with_space = '%s%s' % (seq_id, ' '*(max_seq_id_len + 2 - len(seq_id)))
+            print(seq_id_with_space)
+            msa_out_handle.write('%s%s\n' % (seq_id_with_space, str(each_seq.seq)))
+
+
+#    AlignIO.write(aln_subset, msa_out, 'phylip-relaxed')
+
+
+slice_range = ['1-500', '501-1000', '1001-1500', '1501-2000', '2001-2500', '2501-3000', '3001-3500', '3501-4000', '4001-4500', '4501-4879']
+
+for each_range in slice_range:
+    pwd_msa_op = '/Users/songweizhi/Desktop/%s.phy' % each_range
+    slice_msa_by_col_manual(msa_file, each_range, pwd_msa_op)
+
+
+def fa2phy(fasta_in, phy_out):
+    alignment = AlignIO.read(fasta_in, 'fasta')
+    max_seq_id_len = 0
+    for each_seq in alignment:
+        seq_id_len = len(each_seq.id)
+        if seq_id_len > max_seq_id_len:
+            max_seq_id_len = seq_id_len
+
+    with open(phy_out, 'w') as msa_out_handle:
+        msa_out_handle.write('%s %s\n' % (len(alignment), alignment.get_alignment_length()))
+        for each_seq in alignment:
+            seq_id = each_seq.id
+            seq_id_with_space = '%s%s' % (seq_id, ' ' * (max_seq_id_len + 2 - len(seq_id)))
+            msa_out_handle.write('%s%s\n' % (seq_id_with_space, str(each_seq.seq)))

TreeSAK/cogTree.py

@@ -0,0 +1,185 @@
+import os
+import glob
+import argparse
+from Bio import SeqIO
+import multiprocessing as mp
+
+
+cogTree_usage = '''
+================================ cogTree example commands ================================
+
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG_id.txt
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG00724
+TreeSAK cogTree -i combined.faa -cog arCOG_wd -o op_dir -bmge -t 12 -f -fun arCOG00724,arCOG02271 
+
+==========================================================================================
+'''
+
+
+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 cogTree(args):
+
+    combined_faa            = args['i']
+    cog_annotation_wd       = args['cog']
+    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 cog_annotation_wd is not None:
+
+        print('Reading in COG annotation results')
+        file_re = '%s/*COG_wd/*_query_to_cog.txt' % (cog_annotation_wd)
+        file_list = glob.glob(file_re)
+        if len(file_list) == 0:
+            print('COG 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) == 4:
+                        gene_id = each_line_split[0]
+                        cog_id = each_line_split[1]
+                        if cog_id in interested_fun_set:
+                            if cog_id not in fun_to_gene_dict:
+                                fun_to_gene_dict[cog_id] = set()
+                            fun_to_gene_dict[cog_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__':
+
+    cogTree_parser = argparse.ArgumentParser()
+    cogTree_parser.add_argument('-i',         required=True,                          help='orthologous gene sequence')
+    cogTree_parser.add_argument('-fun',       required=True,                          help='interested functions')
+    cogTree_parser.add_argument('-cog',       required=False, default=None,           help='COG annotation results')
+    cogTree_parser.add_argument('-o',         required=True,                          help='output directory')
+    cogTree_parser.add_argument('-bmge',      required=False, action="store_true",    help='trim with BMGE, default is trimal')
+    cogTree_parser.add_argument('-bmge_m',    required=False, default='BLOSUM30',     help='trim model, default: BLOSUM30')
+    cogTree_parser.add_argument('-bmge_esc',  required=False, default='0.55',         help='entropy score cutoff, default: 0.55')
+    cogTree_parser.add_argument('-iqtree_m',  required=False, default='LG+G+I',       help='iqtree_model, default: LG+G+I')
+    cogTree_parser.add_argument('-f',         required=False, action="store_true",    help='force overwrite')
+    cogTree_parser.add_argument('-t',         required=False, type=int, default=1,    help='num of threads, default: 1')
+    args = vars(cogTree_parser.parse_args())
+    cogTree(args)

TreeSAK/compare_trees.R

@@ -0,0 +1,30 @@
+
+# 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 = 1)}
+
+# install packages if not installed
+packages<-c("optparse", "ape", "vegan")
+invisible(suppressMessages(check.packages(packages)))
+
+option_list = list(
+  make_option(c("-a", "--treeo"),  type="character", default=NULL, help="the first tree"),
+  make_option(c("-b", "--treet"),  type="character", default=NULL, help="the second tree"));
+
+opt_parser = OptionParser(option_list=option_list);
+opt = parse_args(opt_parser);
+
+TREE1 = read.tree(opt$treeo)
+TREE2 = read.tree(opt$treet)
+
+D1 = cophenetic(TREE1)
+D1 = D1[order(row.names(D1)),order(row.names(D1))]
+D2 = cophenetic(TREE2)
+D2 = D2[order(row.names(D2)),order(row.names(D2))]
+
+mantel(xdis = D1, ydis = D2, permutations = 999)
+