FunVIP 0.3.20__py3-none-any.whl

src/modeltest.py

@@ -0,0 +1,443 @@
+from funvip.src import ext
+import os, shutil, copy
+import logging
+
+cmd_translator_modeltestng_fasttree = {
+    "JC": "",
+    "GTR": "-gtr",
+    "JC+G4": "-gamma",
+    "GTR+G4": "-gtr -gamma",
+}
+cmd_translator_modelfinder_fasttree = {
+    "JC": "",
+    "GTR": "-gtr",
+    "JC+G4": "-gamma",
+    "GTR+G4": "-gtr -gamma",
+}
+cmd_translator_modelfinder_raxml = {
+    "JC": "-m JC",
+    "JC+G4": "-m JC",
+    "JC+I": "-m JC",
+    "JC+G4+I": "-m JC",
+    "HKY": "-m HKY85",
+    "HKY+G4": "-m HKY85",
+    "HKY+I": "-m HKY85",
+    "HKY+G4+I": "-m HKY85",
+    "K80": "-m K80",
+    "K80+G4": "-m K80",
+    "TrNef": "-m GTRCAT",
+    "TrNef+G4": "-m GTRGAMMA",
+    "TrNef+I": "-m GTRCATI",
+    "TrNef+G4+I": "-m GTRGAMMAI",
+    "TPM1": "-m GTRCAT",
+    "TPM1+G4": "-m GTRGAMMA",
+    "TPM1+I": "-m GTRCATI",
+    "TPM1+G4+I": "-m GTRGAMMAI",
+    "TPM2": "-m GTRCAT",
+    "TPM2+G4": "-m GTRGAMMA",
+    "TPM2+I": "-m GTRCATI",
+    "TPM2+G4+I": "-m GTRGAMMAI",
+    "TPM3": "-m GTRCAT",
+    "TPM3+G4": "-m GTRGAMMA",
+    "TPM3+I": "-m GTRCATI",
+    "TPM3+G4+I": "-m GTRGAMMAI",
+    "TIM1": "-m GTRCAT",
+    "TIM1+G4": "-m GTRGAMMA",
+    "TIM1+I": "-m GTRCATI",
+    "TIM1+G4+I": "-m GTRGAMMAI",
+    "TIM2": "-m GTRCAT",
+    "TIM2+G4": "-m GTRGAMMA",
+    "TIM2+I": "-m GTRCATI",
+    "TIM2+G4+I": "-m GTRGAMMAI",
+    "TIM3": "-m GTRCAT",
+    "TIM3+G4": "-m GTRGAMMA",
+    "TIM3+I": "-m GTRCATI",
+    "TIM3+G4+I": "-m GTRGAMMAI",
+    "TVMef": "-m GTRCAT",
+    "TVMef+G4": "-m GTRGAMMA",
+    "TVMef+I": "-m GTRCATI",
+    "TVMef+G4+I": "-m GTRGAMMAI",
+    "SYM": "-m GTRCAT",
+    "SYM+G4": "-m GTRGAMMA",
+    "SYM+I": "-m GTRCATI",
+    "SYM+G4+I": "-m GTRGAMMAI",
+    "F81+FO": "-m GTRCATX",
+    "F81+FO+G4": "-m GTRGAMMAX",
+    "F81+FO+I": "-m GTRCATIX",
+    "F81+FO+G4+I": "-m GTRGAMMAIX",
+    "TrN+FO": "-m GTRCATX",
+    "TrN+FO+G4": "-m GTRGAMMAX",
+    "TrN+FO+I": "-m GTRCATIX",
+    "TrN+FO+G4+I": "-m GTRGAMMAIX",
+    "TPM1uf+FO": "-m GTRCATX",
+    "TPM1uf+FO+G4": "-m GTRGAMMAX",
+    "TPM1uf+FO+I": "-m GTRCATIX",
+    "TPM1uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TPM2uf+FO": "-m GTRCATX",
+    "TPM2uf+FO+G4": "-m GTRGAMMAX",
+    "TPM2uf+FO+I": "-m GTRCATIX",
+    "TPM2uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TPM3uf+FO": "-m GTRCATX",
+    "TPM3uf+FO+G4": "-m GTRGAMMAX",
+    "TPM3uf+FO+I": "-m GTRCATIX",
+    "TPM3uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TIM1uf+FO": "-m GTRCATX",
+    "TIM1uf+FO+G4": "-m GTRGAMMAX",
+    "TIM1uf+FO+I": "-m GTRCATIX",
+    "TIM1uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TIM2uf+FO": "-m GTRCATX",
+    "TIM2uf+FO+G4": "-m GTRGAMMAX",
+    "TIM2uf+FO+I": "-m GTRCATIX",
+    "TIM2uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TIM3uf+FO": "-m GTRCATX",
+    "TIM3uf+FO+G4": "-m GTRGAMMAX",
+    "TIM3uf+FO+I": "-m GTRCATIX",
+    "TIM3uf+FO+G4+I": "-m GTRGAMMAIX",
+    "TVM+FO": "-m GTRCATX",
+    "TVM+FO+G4": "-m GTRGAMMAX",
+    "TVM+FO+I": "-m GTRCATIX",
+    "TVM+FO+G4+I": "-m GTRGAMMAIX",
+    "GTR+FO": "-m GTRCATX",
+    "GTR+FO+G4": "-m GTRGAMMAX",
+    "GTR+FO+I": "-m GTRCATIX",
+    "GTR+FO+G4+I": "-m GTRGAMMAIX",
+    "F81": "-m GTRCATX",
+    "F81+G4": "-m GTRGAMMAX",
+    "F81+I": "-m GTRCATIX",
+    "F81+G4+I": "-m GTRGAMMAIX",
+    "TrN": "-m GTRCAT",
+    "TrN+G4": "-m GTRGAMMA",
+    "TrN+I": "-m GTRCATI",
+    "TrN+G4+I": "-m GTRGAMMAI",
+    "TPM1uf": "-m GTRCAT",
+    "TPM1uf+G4": "-m GTRGAMMA",
+    "TPM1uf+I": "-m GTRCATI",
+    "TPM1uf+G4+I": "-m GTRGAMMAI",
+    "TPM2uf": "-m GTRCAT",
+    "TPM2uf+G4": "-m GTRGAMMA",
+    "TPM2uf+I": "-m GTRCATI",
+    "TPM2uf+G4+I": "-m GTRGAMMAI",
+    "TPM3uf": "-m GTRCAT",
+    "TPM3uf+G4": "-m GTRGAMMA",
+    "TPM3uf+I": "-m GTRCATI",
+    "TPM3uf+G4+I": "-m GTRGAMMAI",
+    "TIM1uf": "-m GTRCAT",
+    "TIM1uf+G4": "-m GTRGAMMA",
+    "TIM1uf+I": "-m GTRCATI",
+    "TIM1uf+G4+I": "-m GTRGAMMAI",
+    "TIM2uf": "-m GTRCAT",
+    "TIM2uf+G4": "-m GTRGAMMA",
+    "TIM2uf+I": "-m GTRCATI",
+    "TIM2uf+G4+I": "-m GTRGAMMAI",
+    "TIM3uf": "-m GTRCAT",
+    "TIM3uf+G4": "-m GTRGAMMA",
+    "TIM3uf+I": "-m GTRCATI",
+    "TIM3uf+G4+I": "-m GTRGAMMAI",
+    "TVM": "-m GTRCAT",
+    "TVM+G4": "-m GTRGAMMA",
+    "TVM+I": "-m GTRCATI",
+    "TVM+G4+I": "-m GTRGAMMAI",
+    "GTR": "-m GTRCAT",
+    "GTR+G4": "-m GTRGAMMA",
+    "GTR+I": "-m GTRCATI",
+    "GTR+G4+I": "-m GTRGAMMAI",
+    "F81+F": "-m GTRCAT",
+    "F81+F+G4": "-m GTRGAMMA",
+    "F81+F+I": "-m GTRCATI",
+    "F81+F+G4+I": "-m GTRGAMMAI",
+    "TrN+F": "-m GTRCAT",
+    "TrN+F+G4": "-m GTRGAMMA",
+    "TrN+F+I": "-m GTRCATI",
+    "TrN+F+G4+I": "-m GTRGAMMAI",
+    "TPM1uf+F": "-m GTRCAT",
+    "TPM1uf+F+G4": "-m GTRGAMMA",
+    "TPM1uf+F+I": "-m GTRCATI",
+    "TPM1uf+F+G4+I": "-m GTRGAMMAI",
+    "TPM2uf+F": "-m GTRCAT",
+    "TPM2uf+F+G4": "-m GTRGAMMA",
+    "TPM2uf+F+I": "-m GTRCATI",
+    "TPM2uf+F+G4+I": "-m GTRGAMMAI",
+    "TPM3uf+F": "-m GTRCAT",
+    "TPM3uf+F+G4": "-m GTRGAMMA",
+    "TPM3uf+F+I": "-m GTRCATI",
+    "TPM3uf+F+G4+I": "-m GTRGAMMAI",
+    "TIM1uf+F": "-m GTRCAT",
+    "TIM1uf+F+G4": "-m GTRGAMMA",
+    "TIM1uf+F+I": "-m GTRCATI",
+    "TIM1uf+F+G4+I": "-m GTRGAMMAI",
+    "TIM2uf+F": "-m GTRCAT",
+    "TIM2uf+F+G4": "-m GTRGAMMA",
+    "TIM2uf+F+I": "-m GTRCATI",
+    "TIM2uf+F+G4+I": "-m GTRGAMMAI",
+    "TIM3uf+F": "-m GTRCAT",
+    "TIM3uf+F+G4": "-m GTRGAMMA",
+    "TIM3uf+F+I": "-m GTRCATI",
+    "TIM3uf+F+G4+I": "-m GTRGAMMAI",
+    "TVM+F": "-m GTRCAT",
+    "TVM+F+G4": "-m GTRGAMMA",
+    "TVM+F+I": "-m GTRCATI",
+    "TVM+F+G4+I": "-m GTRGAMMAI",
+    "GTR+F": "-m GTRCAT",
+    "GTR+F+G4": "-m GTRGAMMA",
+    "GTR+F+I": "-m GTRCATI",
+    "GTR+F+G4+I": "-m GTRGAMMAI",
+}
+
+
+def parse_model(modeltest_file, opt, path):
+    model_list = []
+    model_cmd = "no model found"
+
+    if opt.method.modeltest == "iqtree":
+        # Check iqtree - iqtree pair has misentered here
+        if opt.method.tree == "iqtree":
+            logging.error(
+                f"DEVELOPMENTAL ERROR. MODELTEST {opt.method.modeltest} entered while {opt.method.tree} selected"
+            )
+            raise Exception
+
+        # read modeltest result file
+        print(modeltest_file)
+        try:
+            with open(modeltest_file, "r", encoding="UTF-8") as f:
+                lines = f.readlines()
+            logging.info(f"Successfully parsed {modeltest_file}")
+        except:
+            logging.error(f"Cannot parse modeltest file for {modeltest_file}")
+            raise Exception
+
+        # Parse modeltest file
+        flag = 0
+        for line in lines:
+            # finish parsing from new line break
+            if line == "\n" and flag == 1:
+                break
+            # parse when modeltest result existing region
+            if flag == 1:
+                model_list.append(line.split(" ")[0])
+
+            # indicing modeltest result start
+            if (
+                "Model                  LogL         AIC      w-AIC        AICc     w-AICc         BIC      w-BIC"
+                in line
+            ):
+                # parsing flag
+                flag = 1
+
+        # Designate modeltest method by tree method
+        if opt.method.tree == "fasttree":
+            for model in model_list:
+                # if model is available model for tree method take it
+                if model in cmd_translator_modelfinder_fasttree:
+                    # convert to commands
+                    model_cmd = cmd_translator_modelfinder_fasttree[model]
+                    break
+
+            if model_cmd == "no model found":
+                logging.error(f"DEVELOPMENTAL ERROR. FAILED PARSING APPROPRIATE MODEL")
+                logging.error(f"{model_list}")
+                raise Exception
+
+        elif opt.method.tree == "raxml":
+            for model in model_list:
+                # if model is available model for tree method take it
+                if model in cmd_translator_modelfinder_raxml:
+                    # convert to commands
+                    model_cmd = cmd_translator_modelfinder_raxml[model]
+                    break
+
+            if model_cmd == "no model found":
+                logging.error(f"DEVELOPMENTAL ERROR. FAILED PARSING APPROPRIATE MODEL")
+                logging.error(f"{model_list}")
+                raise Exception
+
+        else:
+            logging.error(
+                f"DEVELOPMENTAL ERROR. INAPPROPRIATE TREE METHOD {opt.method.tree} selected"
+            )
+            raise Exception
+
+    elif opt.method.modeltest == "modeltest-ng":
+        ### Testing block ###
+        # Parse files
+
+        try:
+            with open(modeltest_file, "r", encoding="UTF-8") as f:
+                lines = f.readlines()
+                status = None
+
+            # Fasttree needs converter
+            if opt.method.tree == "fasttree":
+                flag = 0  # 1 : Criterion found, 2: --- line found 1st time(while parsing), 0 : parsing ended
+                cnt = 1  # line count
+                for line in lines:
+                    print(f"flag {flag} / [line]: {line}")
+
+                    if (
+                        "model              K            lnL          score          delta    weight"
+                        in line
+                    ):
+                        # Check if the right chunk selected
+                        if "AICc" in line and opt.criterion == "AICc":
+                            flag = 1
+                        elif "AIC" in line and opt.criterion == "AIC":
+                            flag = 1
+                        elif "BIC" in line and opt.criterion == "BIC":
+                            flag = 1
+
+                    elif flag == 1 and "--------" in line:
+                        # Skipping one line
+                        flag = 2
+                    elif flag == 2 and not ("------" in line):
+                        logging.info(f"[line]")
+                        logging.info(line)
+                        # Parsing objects
+                        model_list.append(line.split(f"{cnt}  ")[1].split(" ")[0])
+                        if cnt < 10:
+                            cnt += 1
+                        else:
+                            cnt = 1
+                            # Finish all 10 parsed
+                            break
+                    elif flag == 2 and "------" in line:
+                        # reset block
+                        flag = 0
+
+                # get commands with available model
+                for model in model_list:
+                    if model in cmd_translator_modeltestng_fasttree:
+                        model_cmd = cmd_translator_modeltestng_fasttree[model]
+                        break
+
+            # For IQTREE and RAxML, just easily parse commands
+            else:
+                for line in lines:
+                    # Check current criterion
+                    if "AICc" in line:
+                        status = "AICc"
+                    elif "AIC" in line and not "AICc" in line:
+                        status = "AIC"
+                    elif "BIC" in line:
+                        status = "BIC"
+
+                    if status == opt.criterion:
+                        if line.strip().startswith(">"):
+                            if opt.method.tree == "fasttree":
+                                logging.error(
+                                    f"DEVELOPMENTAL ERROR. MODELTEST-NG COMMAND PARSING STEP entered while {opt.method.tree} selected"
+                                )
+                            elif opt.method.tree == "iqtree":
+                                if "iqtree" in line:
+                                    model_cmd = f'-m {line.split("-m ")[1]}'
+                                    break
+                            elif opt.method.tree == "raxml":
+                                if "raxmlHPC-SSE3" in line:
+                                    model_cmd = (
+                                        f'-m {line.split("-m ")[1].split(" -n ")[0]}'
+                                    )
+                                    break
+
+                # Currently using BIC model
+                model_cmd = model_dict["BIC"]
+
+        except:
+            logging.warning(f"Cannot parse modeltest file for {modeltest_file}")
+
+    else:
+        logging.error(
+            f"DEVELOPMENTAL ERROR. INAPPROPRIATE MODELTEST METHOD {opt.method.modeltest} selected"
+        )
+        raise Exception
+
+    return model_cmd
+
+
+def cleanup(modeltest_file):
+    pass
+
+
+# main function
+def modeltest(V, path, opt) -> dict:
+    group_dict = V.dict_dataset
+    model_dict = copy.deepcopy(group_dict)
+
+    # By group and by gene
+    for group in group_dict:
+        for gene in group_dict[group]:
+            if opt.method.modeltest.lower() == "modeltest-ng":
+                # As modeltest-ng shows only top 10 results,
+                # we should reduce number of models to prevent none of the model fits
+                if opt.method.tree == "fasttree":
+                    models = "-m JC,GTR -h ug"
+                else:
+                    models = ""
+
+                # run modeltest-ng
+                ext.Modeltest_ng(
+                    fasta=f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta",
+                    models=models,
+                    out=f"{path.out_modeltest}/{opt.runname}_{group}_{gene}",
+                    thread=opt.thread,
+                )
+
+                # Change result name
+                try:
+                    shutil.move(
+                        f"{path.out_modeltest}/{opt.runname}_{group}_{gene}.out",
+                        f"{path.out_modeltest}/{opt.runname}_{group}_{gene}.modeltest",
+                    )
+                except:
+                    logging.warning(
+                        f"Cannot parse modeltest file for {path.out_modeltest}/{opt.runname}_{group}_{gene}.out. Running with default option"
+                    )
+
+                # parse model from modeltest-ng result
+                model_dict[group][gene] = parse_model(
+                    modeltest_file=f"{path.out_modeltest}/{opt.runname}_{group}_{gene}.modeltest",
+                    path=path,
+                    opt=opt,
+                )
+            elif opt.method.modeltest.lower() == "iqtree":
+                if not (opt.method.tree == "iqtree"):
+                    # Run IQTREE ModelFinder
+                    ext.ModelFinder(
+                        fasta=f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta",
+                        opt=opt,
+                        path=path,
+                        thread=opt.thread,
+                    )
+
+                    # Move modeltest result to appropriate location
+                    try:
+                        shutil.move(
+                            f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta.iqtree",
+                            f"{path.out_modeltest}/{opt.runname}_{group}_{gene}.modeltest",
+                        )
+                    except:
+                        logging.warning(
+                            f"Cannot parse modeltest file for {path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta.iqtree. Running with default option"
+                        )
+
+                    # parse model from IQTREE ModelFinder result
+                    model_dict[group][gene] = parse_model(
+                        modeltest_file=f"{path.out_modeltest}/{opt.runname}_{group}_{gene}.modeltest",
+                        path=path,
+                        opt=opt,
+                    )
+                else:
+                    logging.info(
+                        "IQTREE will perform ModelFinder internally in tree construction step, skipping in modeltest step"
+                    )
+                    model_dict[group][gene] = "skip"
+
+            else:  # including opt.model_method.lower() == "none":
+                if opt.method.tree == "raxml":
+                    logging.info("Skipping modeltest. Using GTRGAMMA as default")
+                    model_dict[group][gene] = "-m GTRGAMMA"
+                else:
+                    logging.info("Skipping modeltest.")
+                    model_dict[group][gene] = "skip"
+
+    logging.info(model_dict)
+
+    return model_dict

src/ncbi.py

@@ -0,0 +1,160 @@
+from Bio import Entrez
+from Bio import SeqIO
+from Bio.Blast.Applications import NcbiblastnCommandline
+from Bio.Blast import NCBIXML
+from Bio.Seq import Seq
+import time
+from time import sleep
+import pickle
+import json
+import re
+import logging
+from datetime import datetime
+from itertools import repeat
+import xmltodict
+import os, sys, subprocess
+import random
+import pickle
+import pandas as pd
+import shutil
+
+# from .logger import Mes
+
+
+def Downloadbyacclist(Email, list_ID, out):
+    if len(list_ID) == 0:
+        return []
+
+    path_tmp = "tmp_download"
+
+    # print(list_ID)
+
+    def xml2dict(record):
+        dict_type = xmltodict.parse(record)
+        json_type = json.dumps(dict_type, indent=4)
+        dict2_type = json.loads(json_type)
+        return dict2_type
+
+    Entrez.email = Email
+
+    logging.info(f"Number of IDs: {len(list_ID)}")
+
+    # Parse
+    cnt = 0
+    cut = 50  # parse by 50 sequences
+    cnt_all = len(list_ID)
+
+    start_time = time.time()
+
+    record_list = []
+
+    for i in range(int((len(list_ID) - 1) / cut) + 1):
+        # last chunk
+        if i * cut + cut > len(list_ID):
+            # Mes(i)
+            ID_string = ",".join(list_ID[i * cut :])
+            sleep(0.3)
+            cnt += len(list_ID[i * cut :])
+            logging.info(
+                f"{cnt}/{cnt_all} {100*cnt/cnt_all}% {time.time()-start_time}s"
+            )
+
+            try:
+                print(ID_string)
+                handle = Entrez.efetch(
+                    db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                )
+            except:  # Retry
+                logging.info("Requesting again...")
+                try:
+                    sleep(10)
+                    handle = Entrez.efetch(
+                        db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                    )
+                except:
+                    sleep(100)
+                    handle = Entrez.efetch(
+                        db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                    )
+
+            pre_record = handle.read()
+            json_record = xml2dict(pre_record)
+            tmp_record_list = []
+
+            # If only one result available
+            if type(json_record["GBSet"]["GBSeq"]) is dict:
+                json_record["GBSet"]["GBSeq"] = [json_record["GBSet"]["GBSeq"]]
+
+            if len(list_ID[i * cut :]) != 1:
+                for record in json_record["GBSet"]["GBSeq"]:
+                    print(record)
+                    record_list.append(record)
+                    tmp_record_list.append(record)
+            else:
+                record = json_record["GBSet"]["GBSeq"]
+                record_list.append(record)
+                tmp_record_list.append(record)
+
+            try:
+                with open(f"./{path_tmp}/{i}", "wb") as f:
+                    pickle.dump(tmp_record_list, f)
+            except:
+                logging.error("Saving Error")
+                raise Exception
+
+        # non last chunk
+        else:
+            # Mes(i)
+            ID_string = ",".join(list_ID[i * cut : i * cut + cut])
+            sleep(0.3)
+            cnt += cut
+            logging.info(
+                f"{cnt}/{cnt_all} {100*cnt/cnt_all}% {time.time()-start_time}s"
+            )
+
+            try:
+                handle = Entrez.efetch(
+                    db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                )
+            except:  # Retry
+                logging.info("Requesting again...")
+                try:
+                    sleep(10)
+                    handle = Entrez.efetch(
+                        db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                    )
+                except:
+                    sleep(100)
+                    handle = Entrez.efetch(
+                        db="nucleotide", id=ID_string, rettype="gb", retmode="xml"
+                    )
+
+            pre_record = handle.read()
+            json_record = xml2dict(pre_record)
+            tmp_record_list = []
+
+            if len(list_ID[i * cut :]) != 1:
+                for record in json_record["GBSet"]["GBSeq"]:
+                    record_list.append(record)
+                    tmp_record_list.append(record)
+            else:
+                record = json_record["GBSet"]["GBSeq"]
+                record_list.append(record)
+                tmp_record_list.append(record)
+
+            try:
+                with open(f"./{path_tmp}/{i}", "wb") as f:
+                    pickle.dump(tmp_record_list, f)
+            except:
+                logging.error("Saving Error")
+                raise Exception
+
+    with open(out, "w") as fp:
+        json_term = json.dump(record_list, fp, indent=4)
+
+    # If success, remove tmp files
+    tmp_file_list = [file for file in os.listdir(f"./{path_tmp}/")]
+    for file in tmp_file_list:
+        os.remove(f"./{path_tmp}/{file}")
+
+    return record_list

src/opt_generator.py

@@ -0,0 +1,72 @@
+# Option generator for multiprocessing starmap
+import logging
+import os
+
+
+def opt_generator(V, opt, path, step, thread=None):
+    list_opt = []
+
+    if thread is None:
+        thread = opt.thread
+
+    ## alignment options generator
+    if step == "alignment":
+        for group in V.dict_dataset:
+            for gene in V.dict_dataset[group]:
+                # For concatenated gene matrix, alignment should be done by each gene matrix and then concatenated
+                if gene != "concatenated":
+                    # double checking path
+                    if os.path.isfile(
+                        f"{path.out_adjusted}/{opt.runname}_Adjusted_{group}_{gene}.fasta"
+                    ):
+                        list_opt.append(
+                            (
+                                f"{path.out_adjusted}/{opt.runname}_Adjusted_{group}_{gene}.fasta",
+                                f"{path.out_alignment}/{opt.runname}_MAFFT_{group}_{gene}.fasta",
+                                path,
+                                thread,
+                                opt.mafft.algorithm,
+                                "adjustdirection",
+                                opt.mafft.op,
+                                opt.mafft.ep,
+                            )
+                        )
+
+    elif step == "trimming":
+        # Generate trimming opts for multiprocessing
+        for group in V.dict_dataset:
+            for gene in V.dict_dataset[group]:
+                if not (gene == "concatenated"):
+                    if opt.method.trim.lower() == "gblocks":
+                        list_opt.append(
+                            (
+                                f"{path.out_alignment}/{opt.runname}_MAFFT_{group}_{gene}.fasta",
+                                f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta",
+                                path,
+                                opt,
+                            )
+                        )
+                    elif opt.method.trim.lower() == "trimal":
+                        list_opt.append(
+                            (
+                                f"{path.out_alignment}/{opt.runname}_MAFFT_{group}_{gene}.fasta",
+                                f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta",
+                                path,
+                                opt,
+                            )
+                        )
+                    else:  # for just copy
+                        list_opt.append(
+                            (
+                                f"{path.out_alignment}/{opt.runname}_MAFFT_{group}_{gene}.fasta",
+                                f"{path.out_alignment}/{opt.runname}_trimmed_{group}_{gene}.fasta",
+                                path,
+                                opt,
+                            )
+                        )
+
+    else:
+        logging.error(f"[Error] Unexpected step {step} given for opt_generator")
+        raise Exception
+
+    return list_opt