treesak 1.53.3__py3-none-any.whl

TreeSAK/subset_tree_stupid_old_way.py

@@ -0,0 +1,193 @@
+import os
+import copy
+import argparse
+from Bio import Phylo
+from datetime import datetime
+
+
+subset_tree_usage = '''
+========================== subset_tree example command ==========================
+
+BioSAK subset_tree -tree tree_in.newick -taxon leaves.txt -out tree_out.newick
+
+=================================================================================
+'''
+
+
+def check_to_keep(clade_name_str, identified_taxon_list):
+
+    # remove colon form clade name
+    clade_name_str_no_colon = clade_name_str
+    if ':' in clade_name_str_no_colon:
+        clade_name_str_no_colon = clade_name_str_no_colon.split(':')[1]
+
+    # split clade name if there are ';'
+    for_check = []
+    if ';' in clade_name_str_no_colon:
+        clade_name_str_no_colon_split = clade_name_str_no_colon.split(';')
+
+        # remove space at the begining or end for each split
+        clade_name_str_no_colon_split_no_space = []
+        for clade_name in clade_name_str_no_colon_split:
+            if clade_name[0] == ' ':
+                clade_name = clade_name[1:]
+            if clade_name[-1] == ' ':
+                clade_name = clade_name[:-1]
+            clade_name_str_no_colon_split_no_space.append(clade_name)
+        for_check = clade_name_str_no_colon_split_no_space
+    else:
+        for_check = [clade_name_str_no_colon]
+
+    # check to keep or not
+    clade_to_keep = 0
+    for identified_taxon in identified_taxon_list:
+        if identified_taxon in for_check:
+            clade_to_keep = 1
+
+    return clade_to_keep
+
+
+def remove_unwanted_leaf_nodes(tree, identified_taxon_list):
+
+    # copy tree
+    tree_copy = copy.deepcopy(tree)
+
+    removed_leaf_num = 0
+    all_leaf_nodes = tree_copy.get_terminals()
+    for leaf_node in all_leaf_nodes:
+        leaf_node_name_str = str(leaf_node.name)
+        leaf_node_to_keep = check_to_keep(leaf_node_name_str, identified_taxon_list)
+
+        if leaf_node_to_keep == 0:
+            tree_copy.collapse(leaf_node)
+            removed_leaf_num += 1
+
+    return tree_copy, removed_leaf_num
+
+
+def subset_tree(args):
+
+    ################################################# input #################################################
+
+    tree_file_in        = args['tree']
+    group_to_taxon_file = args['taxon']
+    tree_file_out       = args['out']
+    keep_quiet          = args['q']
+
+    # define tmp file name
+    tree_file_tmp_1 = '%s.tmp_1.tree' % tree_file_out
+    tree_file_tmp_2 = '%s.tmp_2.tree' % tree_file_out
+    time_format     = '[%Y-%m-%d %H:%M:%S] '
+
+    ################################################ store input information ###########################################
+
+    # read in tree
+    tree_in = Phylo.read(tree_file_in, 'newick')
+
+    # read in all identified taxons
+    identified_taxon_list = set()
+    for each_group in open(group_to_taxon_file):
+        identified_taxon_list.add(each_group.strip())
+
+    if keep_quiet is False:
+        print(datetime.now().strftime(time_format) + 'The number of provided taxon: %s' % len(identified_taxon_list))
+
+    ########################################## remove unwanted nodes recursively #######################################
+
+    # remove unwanted nodes recursively
+    if keep_quiet is False:
+        print(datetime.now().strftime(time_format) + 'Recursively removing unwanted nodes')
+    deleted_leaf_num = 1
+    n = 0
+    tree_in_copy = copy.deepcopy(tree_in)
+    while deleted_leaf_num > 0:
+        tree_in_copy, deleted_leaf_num = remove_unwanted_leaf_nodes(tree_in_copy, identified_taxon_list)
+        n += 1
+        if keep_quiet is False:
+            print(datetime.now().strftime(time_format) + 'Removed %s nodes in %sth round' % (deleted_leaf_num, n))
+
+    # write out tree
+    Phylo.write(tree_in_copy, tree_file_tmp_1, 'newick')
+
+    ############################################# remove "100:" in clade name ##########################################
+
+    # read in tree
+    tree_tmp_1 = Phylo.read(tree_file_tmp_1, 'newick')
+    tree_tmp_1_copy = copy.deepcopy(tree_tmp_1)
+
+    for clade in tree_tmp_1_copy.find_clades():
+        clade_name = str(clade.name)
+        if ':' in clade_name:
+            clade.name = clade_name.split(':')[1]
+
+    Phylo.write(tree_tmp_1_copy, tree_file_tmp_2, 'newick')
+
+    ################################################ rename leaf nodes name ############################################
+
+    # read in tree
+    tree_tmp_2 = Phylo.read(tree_file_tmp_2, 'newick')
+    tree_tmp_2_copy = copy.deepcopy(tree_tmp_2)
+
+    # get all leaf nodes
+    all_leaf_nodes = tree_tmp_2_copy.get_terminals()
+    for leaf_node in all_leaf_nodes:
+        leaf_node_name_str = str(leaf_node.name)
+
+        if ';' in leaf_node_name_str:
+            leaf_node_name_split = leaf_node_name_str.split(';')
+
+            # remove space at the begining or end
+            leaf_node_name_split_no_space = []
+            for each_name in leaf_node_name_split:
+                if each_name[0] == ' ':
+                    each_name = each_name[1:]
+                if each_name[-1] == ' ':
+                    each_name = each_name[:-1]
+                leaf_node_name_split_no_space.append(each_name)
+
+            leaf_node_name_new = ''
+            for identified_taxon in identified_taxon_list:
+                if identified_taxon in leaf_node_name_split_no_space:
+                    leaf_node_name_new = identified_taxon
+
+            leaf_node.name = leaf_node_name_new
+
+    # write out tree
+    Phylo.write(tree_tmp_2_copy, tree_file_out, 'newick')
+
+    # report
+    if keep_quiet is False:
+        print(datetime.now().strftime(time_format) + 'Tree subset exported to: %s' % tree_file_out)
+
+    # print warning message if some provided node(s) were not found
+    extracted_leaf_nodes = tree_tmp_2_copy.get_terminals()
+    if len(extracted_leaf_nodes) < len(identified_taxon_list):
+
+        extracted_leaf_node_list = []
+        for extracted_leaf_node in extracted_leaf_nodes:
+            extracted_leaf_node_list.append(str(extracted_leaf_node.name))
+
+        un_extracted_nodes = []
+        for provided_node in identified_taxon_list:
+            if provided_node not in extracted_leaf_node_list:
+                un_extracted_nodes.append(provided_node)
+
+        if keep_quiet is False:
+            print(datetime.now().strftime(time_format) + 'Warning!!! Found %s of %s provided nodes, missed: %s' % (len(extracted_leaf_nodes), len(identified_taxon_list), ', '.join(un_extracted_nodes)))
+
+    ################################################### remove tmp files ###############################################
+
+    # remove tmp files
+    os.remove(tree_file_tmp_1)
+    os.remove(tree_file_tmp_2)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='', add_help=False)
+    parser.add_argument('-h',     action='help',                        help='Show this help message and exit')
+    parser.add_argument('-tree',  required=True,  type=str,             help='input tree file')
+    parser.add_argument('-taxon', required=True,  type=str,             help='A file containing list of leaves to keep, one leaf per line')
+    parser.add_argument('-out',   required=True,  type=str,             help='Output tree file')
+    parser.add_argument('-q',     required=False, action="store_true",  help='do not report progress')
+    args = vars(parser.parse_args())
+z

TreeSAK/supertree.py

@@ -0,0 +1,330 @@
+import os
+import glob
+import argparse
+from ete3 import Tree
+from Bio import AlignIO
+import multiprocessing as mp
+
+
+supertree_usage = '''
+====================== supertree example commands ======================
+
+Dependencies: mafft, trimal, bmge and iqtree2
+
+TreeSAK supertree -i best10 -x fa -o best10_astral_tree -bmge -t 12 -f
+
+========================================================================
+'''
+
+
+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 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)))
+
+
+def PB(msa_in, op_dir, op_prefix, fa_to_plp, num_of_threads, num_of_chains, force_overwrite):
+
+    ####################################################################################################################
+
+    msa_in_name, msa_in_path, msa_in_base, msa_in_ext = sep_path_basename_ext(msa_in)
+
+    settings_dombrowski = '-cat -gtr -x 10 -1 -dgam 4'
+    setting_to_use  = settings_dombrowski
+    msa_in_plp      = '%s/%s.phylip'        % (op_dir, msa_in_base)
+    cmd_txt         = '%s/%s_cmds.txt'      % (op_dir, msa_in_base)
+
+    ####################################################################################################################
+
+    # create output dir
+    if os.path.isdir(op_dir) is True:
+        if force_overwrite is True:
+            os.system('rm -r %s' % op_dir)
+        else:
+            print('output folder already exist, program exited!')
+            exit()
+    os.system('mkdir %s' % op_dir)
+
+    # fa_to_phylip
+    msa_to_use = msa_in
+    if fa_to_plp is True:
+        fa2phy(msa_in, msa_in_plp)
+        msa_to_use = msa_in_plp
+
+    cores_per_chain = 0
+    chain_name_list = []
+    pb_mpi_cmd_list = []
+    jobs_to_run_in_parallel = 0
+    if num_of_chains == 1:
+        jobs_to_run_in_parallel = 1
+        pb_mpi_cmd = 'mpirun -np %s pb_mpi -d %s %s -s %s/%s' % (num_of_threads, msa_to_use, setting_to_use, op_dir, op_prefix)
+        chain_name_list.append('%s/%s' % (op_dir, op_prefix))
+        pb_mpi_cmd_list.append(pb_mpi_cmd)
+        cores_per_chain = num_of_threads
+
+    elif num_of_threads <= num_of_chains:
+        jobs_to_run_in_parallel = num_of_threads
+        for chain_index in range(1, (num_of_chains + 1)):
+            current_wd = '%s/%s_chain%s' % (op_dir, op_prefix, chain_index)
+            os.mkdir(current_wd)
+            pb_mpi_cmd = 'mpirun -np %s pb_mpi -d %s %s -s %s/%s_chain%s' % (1, msa_to_use, setting_to_use, current_wd, op_prefix, chain_index)
+            chain_name_list.append('%s/%s_chain%s' % (current_wd, op_prefix, chain_index))
+            pb_mpi_cmd_list.append(pb_mpi_cmd)
+            cores_per_chain = 1
+    else:
+        jobs_to_run_in_parallel = num_of_chains
+        cores_per_run = num_of_threads // num_of_chains
+        for chain_index in range(1, (num_of_chains + 1)):
+            current_wd = '%s/%s_chain%s' % (op_dir, op_prefix, chain_index)
+            os.mkdir(current_wd)
+            pb_mpi_cmd = 'mpirun -np %s pb_mpi -d %s %s -s %s/%s_chain%s' % (cores_per_run, msa_to_use, setting_to_use, current_wd, op_prefix, chain_index)
+            chain_name_list.append('%s/%s_chain%s' % (current_wd, op_prefix, chain_index))
+            pb_mpi_cmd_list.append(pb_mpi_cmd)
+            cores_per_chain = cores_per_run
+
+    # write out commands
+    cmd_txt_handle = open(cmd_txt, 'w')
+    for cmd in pb_mpi_cmd_list:
+        cmd_txt_handle.write(cmd + '\n')
+
+    cmd_txt_handle.write('\n# To restart a terminated run (e.g., due to walltime limitation)\n')
+    for each_chain in chain_name_list:
+        cmd_txt_handle.write('mpirun -np %s pb_mpi %s\n' % (cores_per_chain, each_chain))
+    cmd_txt_handle.close()
+
+    # run chains with mp
+    print('Running pb_mpi with multiprocessing')
+    pool = mp.Pool(processes=jobs_to_run_in_parallel)
+    pool.map(os.system, pb_mpi_cmd_list)
+    pool.close()
+    pool.join()
+
+    # assess the results
+    if num_of_chains > 1:
+
+        readpb_cmd = 'bpcomp -x 1000 10 %s' % (' '.join(chain_name_list))
+        bpcomp_cmd = 'tracecomp -x 1000 %s' % (' '.join(chain_name_list))
+
+        # write out commands
+        cmd_txt_handle = open(cmd_txt, 'a')
+        cmd_txt_handle.write(readpb_cmd + '\n')
+        cmd_txt_handle.write(bpcomp_cmd + '\n')
+        cmd_txt_handle.close()
+
+        # report
+        print('You may want to use the following commands to assess the results:')
+        print(readpb_cmd)
+        print(bpcomp_cmd)
+
+    print('Done!')
+
+
+def supertree(args):
+
+    oma_op_fasta            = args['i']
+    fasta_file_ext          = args['x']
+    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']
+    infer_pb_tree           = args['pb']
+
+    # specify path to BMGE.jar
+    current_file_path = '/'.join(os.path.realpath(__file__).split('/')[:-1])
+    pwd_bmge_jar = '%s/BMGE.jar' % current_file_path
+
+    fa_file_re   = '%s/*.%s' % (oma_op_fasta, fasta_file_ext)
+    fa_file_list = ['.'.join(os.path.basename(i).split('.')[:-1]) for i in glob.glob(fa_file_re)]
+
+    if len(fa_file_list) == 0:
+        print('No file found in %s, program exited!' % oma_op_fasta)
+        exit()
+
+    ################################################################################
+
+    # define file name
+    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
+    cmd_4_astral_txt        = '%s/cmd_4_astral.txt'         % op_dir
+    aln_dir                 = '%s/dir_1_msa'                % op_dir
+    trimmed_aln_dir         = '%s/dir_2_trimmed_msa'        % op_dir
+    tree_dir                = '%s/dir_3_tree'               % op_dir
+    combined_gene_tree_file = '%s/combined_trees.txt'       % op_dir
+    astral_mapping_txt      = '%s/name_mapping.txt'         % op_dir
+    consensus_tree_txt      = '%s/consensus_tree.treefile'  % 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(aln_dir)
+    os.mkdir(trimmed_aln_dir)
+    os.mkdir(tree_dir)
+
+    ################################################################################
+
+    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_og in sorted(fa_file_list):
+
+        # define file name
+        current_gene_tree_dir   = '%s/dir_3_tree/%s'    % (op_dir, each_og)
+        og_fa                   = '%s/%s.%s'            % (oma_op_fasta, each_og, fasta_file_ext)
+        og_aln                  = '%s/%s.aln'           % (aln_dir, each_og)
+        og_aln_trimmed          = '%s/%s_trimal.aln'    % (trimmed_aln_dir, each_og)
+        if trim_with_bmge is True:
+            og_aln_trimmed      = '%s/%s_bmge.aln'      % (trimmed_aln_dir, each_og)
+
+        os.system('mkdir %s' % current_gene_tree_dir)
+
+        # prepare commands
+        mafft_cmd          = 'mafft-einsi --thread %s --quiet %s > %s'                                             % (1, og_fa, og_aln)
+
+        trim_cmd           = 'trimal -in %s -out %s -automated1'                                                   % (og_aln, og_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, og_aln, trim_model, entropy_score_cutoff, og_aln_trimmed)
+
+        infer_tree_cmd     = 'iqtree2 -s %s --seqtype AA -m %s -B 1000 --wbtl --bnni --prefix %s/%s -T %s --quiet' % (og_aln_trimmed, iqtree_model, current_gene_tree_dir, each_og, num_of_threads)
+        if infer_pb_tree is True:
+            infer_tree_cmd = 'TreeSAK PB -i %s -o %s -p %s -t %s -n %s -fa2plp'                                    % (og_aln_trimmed, current_gene_tree_dir, each_og, num_of_threads, 4)
+
+        # 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 OGs' % (num_of_threads, len(fa_file_list)))
+    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 OGs' % (num_of_threads, len(fa_file_list)))
+    pool = mp.Pool(processes=num_of_threads)
+    pool.map(os.system, cmd_list_trim)
+    pool.close()
+    pool.join()
+
+    # run iqtree commands
+    if infer_pb_tree is False:
+        print('Running iqtree with %s cores for %s OGs' % (num_of_threads, len(fa_file_list)))
+        for each_iqtree_cmd in sorted(cmd_list_tree):
+            print(each_iqtree_cmd)
+            os.system(each_iqtree_cmd)
+    else:
+        print('Commands for inferring PhyloBayes tree exported to %s' % cmd_3_tree_txt)
+
+    #################################################### run astral ####################################################
+
+    if infer_pb_tree is False:
+
+        # cat gene trees
+        os.system('cat %s/*.treefile > %s' % (tree_dir, combined_gene_tree_file))
+
+        gnm_to_gene_dict = dict()
+        for each_tree in open(combined_gene_tree_file):
+            tree_str = each_tree.strip()
+            current_tree = Tree(tree_str, quoted_node_names=True, format=1)
+            for node in current_tree.traverse():
+                if node.is_leaf():
+                    leaf_name = node.name
+                    leaf_gnm = '_'.join(leaf_name.split('_')[:-1])
+                    if leaf_gnm not in gnm_to_gene_dict:
+                        gnm_to_gene_dict[leaf_gnm] = {leaf_name}
+                    else:
+                        gnm_to_gene_dict[leaf_gnm].add(leaf_name)
+
+        # get the mapping file
+        astral_mapping_txt_handle = open(astral_mapping_txt, 'w')
+        for each_gnm in gnm_to_gene_dict:
+            current_gene_set = gnm_to_gene_dict[each_gnm]
+            for each_gene in current_gene_set:
+                astral_mapping_txt_handle.write('%s\t%s\n' % (each_gene, each_gnm))
+        astral_mapping_txt_handle.close()
+
+        # may need to add more parameters
+        astral_cmd = 'astral -i %s -o %s -t %s -a %s' % (combined_gene_tree_file, consensus_tree_txt, num_of_threads, astral_mapping_txt)
+        # -r    --round     Integer 4       Number of initial rounds of placements
+        # -s    --subsample Integer 4       Number of rounds of subsampling per exploration step
+
+        # write out command
+        cmd_4_astral_txt_handle = open(cmd_4_astral_txt, 'w')
+        cmd_4_astral_txt_handle.write(astral_cmd + '\n')
+        cmd_4_astral_txt_handle.close()
+
+        # run astral
+        os.system(astral_cmd)
+
+    else:
+        print('Things to do:')
+        print('Run PhyloBayes with commands exported to %s' % cmd_3_tree_txt)
+        print('Wait until your chains, for each of your protein family, reached convergence')
+        print('1. get consensus gene tree for each protein family usingn')
+        print('2. get species tree based on the consensus gene trees with trimal')
+
+    ####################################################################################################################
+
+
+if __name__ == '__main__':
+
+    supertree_parser = argparse.ArgumentParser()
+    supertree_parser.add_argument('-i',         required=True,                          help='orthologous gene sequence')
+    supertree_parser.add_argument('-x',         required=True,                          help='faa file extension')
+    supertree_parser.add_argument('-o',         required=True,                          help='output directory')
+    supertree_parser.add_argument('-bmge',      required=False, action="store_true",    help='trim with BMGE, default is trimal')
+    supertree_parser.add_argument('-bmge_m',    required=False, default='BLOSUM30',     help='trim model, default: BLOSUM30')
+    supertree_parser.add_argument('-bmge_esc',  required=False, default='0.55',         help='entropy score cutoff, default: 0.55')
+    supertree_parser.add_argument('-iqtree_m',  required=False, default='LG+G+I',       help='iqtree_model, default: LG+G+I')
+    supertree_parser.add_argument('-pb',        required=False, action="store_true",    help='infer tree with PhyloBayes-MPI, default is iqtree')
+    supertree_parser.add_argument('-f',         required=False, action="store_true",    help='force overwrite')
+    supertree_parser.add_argument('-t',         required=False, type=int, default=1,    help='num of threads, default: 1')
+    args = vars(supertree_parser.parse_args())
+    supertree(args)

TreeSAK/tmp_1.py

@@ -0,0 +1,19 @@
+
+def gene_gain_and_loss(TableEvents_tsv):
+
+    for each_line in open(TableEvents_tsv):
+        if not each_line.startswith('Family\tBranchType\tBranch'):
+            each_line_split = each_line.strip().split('\t')
+            protein_family_id   = each_line_split[0]
+            node_id             = each_line_split[2]
+            Losses              = float(each_line_split[5])
+            Originations        = float(each_line_split[6])
+            Extinctinonprob     = float(each_line_split[9])
+
+            print('%s\t%s\t%s\t%s\t%s' % (protein_family_id, node_id, Losses, '', Extinctinonprob))
+
+
+TableEvents_tsv = '/Users/songweizhi/Desktop/Sponge_r220/10_dRep95_255_ALE_wd/dRep95_255_ALE3_op_dir_80/TableEvents.tsv'
+
+gene_gain_and_loss(TableEvents_tsv)
+

TreeSAK/tmp_2.py

@@ -0,0 +1,19 @@
+from Bio import SeqIO
+
+
+def filter_by_gap(file_in, max_gap_pct, file_out):
+    file_out_handle = open(file_out, 'w')
+    for each_seq in SeqIO.parse(file_in, 'fasta'):
+        seq_str = str(each_seq.seq)
+        gap_num = seq_str.count('-')
+        gap_pct = gap_num*100 / len(seq_str)
+        if gap_pct <= float(max_gap_pct):
+            file_out_handle.write('>%s\n%s\n' % (each_seq.id, seq_str))
+    file_out_handle.close()
+
+
+file_in     = '/Users/songweizhi/Desktop/Jianwei_Maggie/mmseqs_cov0.85_iden0.35/All_PeptidaseS9-RiPPs_dna100_realRiPPS9100_addref.mmseqs.iden0.35.cov0.85.representatives.trimal.aln'
+max_gap_pct = 40
+file_out    = '/Users/songweizhi/Desktop/Jianwei_Maggie/mmseqs_cov0.85_iden0.35/All_PeptidaseS9-RiPPs_dna100_realRiPPS9100_addref.mmseqs.iden0.35.cov0.85.representatives.trimal.maxgap40.aln'
+
+filter_by_gap(file_in, max_gap_pct, file_out)

TreeSAK/tmp_3.py

@@ -0,0 +1,120 @@
+import os
+import argparse
+import arviz as az
+import pandas as pd
+import matplotlib as mpl
+mpl.use('Agg')
+import matplotlib.pyplot as plt
+from matplotlib.pyplot import figure
+
+
+CompareMCMC_usage = '''
+====================================== CompareMCMC example commands ======================================
+
+TreeSAK CompareMCMC -mx IR_mcmc.txt -my AR_mcmc.txt -lx IR -ly AR -o convergence_plot.png -max 40 -fs 12
+
+cd /Users/songweizhi/Desktop
+TreeSAK CompareMCMC -mx /Users/songweizhi/Desktop/Sponge_r220/6_dating/MCMCTree/dating_outputs/topo2p10_clock3_nsample250000_run1_mcmc.txt -my /Users/songweizhi/Desktop/Sponge_r220/6_dating/MCMCTree/dating_outputs/topo2p10_clock3_nsample250000_run2_mcmc.txt -lx IR -ly AR -o convergence_plot.png -max 40 -fs 12
+
+==========================================================================================================
+'''
+
+
+def sep_path_basename_ext(file_in):
+    file_path, file_name = os.path.split(file_in)
+    if file_path == '':
+        file_path = '.'
+    file_basename, file_extension = os.path.splitext(file_name)
+    return file_path, file_basename, file_extension
+
+
+def CompareMCMC():
+
+    # mcmc_txt_x      = args['mx']
+    # mcmc_txt_y      = args['my']
+    # label_x         = args['lx']
+    # label_y         = args['ly']
+    # pwd_figure      = args['o']
+    # max_axis_value  = args['max']
+    # label_fs        = args['fs']
+
+    label_fs = 16
+    file_x = '/Users/songweizhi/Desktop/x.txt'
+    file_y = '/Users/songweizhi/Desktop/y.txt'
+    pwd_figure = '/Users/songweizhi/Desktop/Figures.pdf'
+    min_value = 0
+    max_value = 1
+    max_axis_value = 1
+    label_x = []
+    num_list_x = []
+    x_err_l = []
+    x_err_r = []
+    line_num_index = 0
+    for line in open(file_x):
+        line_split = line.strip().split('\t')
+        if line_num_index > 0:
+            label_x.append(line_split[0])
+            num_list_x.append(float(line_split[1]))
+            x_err_l.append(float(line_split[1]) - float(line_split[2]))
+            x_err_r.append(float(line_split[3]) - float(line_split[1]))
+        line_num_index += 1
+
+
+    label_y = []
+    num_list_y = []
+    y_err_l = []
+    y_err_u = []
+    line_num_index = 0
+    for line in open(file_y):
+        line_split = line.strip().split('\t')
+        if line_num_index > 0:
+            label_y.append(line_split[0])
+            num_list_y.append(float(line_split[1]))
+            y_err_l.append(float(line_split[1]) - float(line_split[2]))
+            y_err_u.append(float(line_split[3]) - float(line_split[1]))
+        line_num_index += 1
+
+
+
+
+
+
+    figure(figsize=(6, 6), dpi=300)
+    plt.plot([min_value, max_value], [min_value, max_value], color='black', linestyle='dashed', linewidth=1, alpha=0.5)
+    plt.scatter(num_list_x, num_list_y, s=0)
+    plt.errorbar(num_list_x, num_list_y, xerr=[x_err_l, x_err_r], yerr=[y_err_l, y_err_u],
+                 ls='none', ecolor='skyblue', elinewidth=1, alpha=0.5)
+
+    if max_axis_value is not None:
+        plt.xlim([0, max_axis_value])
+        plt.ylim([0, max_axis_value])
+
+    # Set the font size of xticks and yticks
+    plt.xticks(fontsize=label_fs)
+    plt.yticks(fontsize=label_fs)
+    plt.xlabel(label_x, fontsize=label_fs)
+    plt.ylabel(label_y, fontsize=label_fs)
+
+    # write out
+    plt.tight_layout()
+    plt.savefig(pwd_figure)
+    plt.close()
+
+    print('Plot exported to %s, done!' % pwd_figure)
+
+
+CompareMCMC()
+
+# if __name__ == '__main__':
+#
+#     # initialize the options parser
+#     parser = argparse.ArgumentParser()
+#     parser.add_argument('-mx',      required=True,                          help='mcmc.txt for x axis')
+#     parser.add_argument('-my',      required=True,                          help='mcmc.txt for y axis')
+#     parser.add_argument('-lx',      required=False, default=None,           help='label for x axis')
+#     parser.add_argument('-ly',      required=False, default=None,           help='label for y axis')
+#     parser.add_argument('-max',     required=False, default=None, type=int, help='maximum axis value')
+#     parser.add_argument('-fs',      required=False, default=16, type=int,   help='label font size, default: 16')
+#     parser.add_argument('-o',       required=True,                          help='output plot')
+#     args = vars(parser.parse_args())
+#     CompareMCMC(args)