biastools 0.3.2__py3-none-any.whl

biastools/__init__.py

@@ -0,0 +1,3 @@
+#biastools
+import biastools.biastools
+import biastools.biastools_scan

biastools/biastools.py

@@ -0,0 +1,307 @@
+# Wrap up python file for the biastools 1st and 2nd module
+import subprocess
+import sys
+import os
+import argparse
+from shutil import which
+
+def is_tool(name):
+    """Check whether `name` is on PATH and marked as executable."""
+    return which(name) is not None
+
+
+def check_program_install(list_names):
+    flag_violate = False
+    for name in list_names:
+        if is_tool(name) == False:
+            print(name, "is a prerequisite program, please install it before running biastools")
+            flag_violate = True
+    if flag_violate:
+        print("Use --force option if you want to disable the prerequisite program check.")
+        exit(1)
+
+
+def bool2str(flag):
+    if flag:
+        return "1"
+    else:
+        return "0"
+
+
+def catch_assert(parser, message):
+    print('\n', message, '\n')
+    parser.print_usage()
+    exit(1)
+
+
+def ensure_processed_vcf(path_ref, path_vcf, path_output, sample_id, path_module, parser):
+    """
+    Ensure that the processed heterozygous VCF (<out>/<sample_id>.het.vcf.gz) exists.
+    If it doesn't, regenerate it in the same way as in the simulation/analysis shell scripts.
+    """
+    het_vcf_path = path_output + '/' + sample_id + '.het.vcf.gz'
+    if os.path.exists(het_vcf_path):
+        return het_vcf_path
+
+    try:
+        assert path_ref is not None
+        assert path_vcf is not None
+    except AssertionError:
+        catch_assert(
+            parser,
+            "<genome> and <vcf> should be specified when using --analyze "
+            "if the processed VCF does not already exist in the output directory.",
+        )
+
+    prefix = path_output + '/' + sample_id
+    print("[Biastools] Prepare processed VCF for analysis...")
+    # Normalize the input VCF against the reference
+    subprocess.check_call([
+        'bcftools', 'norm',
+        '-f', path_ref,
+        path_vcf,
+        '-m', '+any',
+        '-Oz',
+        '-o', prefix + '.normalized.vcf.gz',
+    ])
+    subprocess.check_call(['bcftools', 'index', prefix + '.normalized.vcf.gz'])
+
+    # Filter heterozygous sites and index the resulting VCF
+    subprocess.check_call([
+        'python3',
+        path_module + 'filter_het_VCF.py',
+        '-v', prefix + '.normalized.vcf.gz',
+        '-o', het_vcf_path,
+    ])
+    subprocess.check_call(['tabix', '-p', 'vcf', het_vcf_path])
+
+    return het_vcf_path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Simulation/Alignment/Analyzing/Prediction module of the Biastools v0.3.2")
+    parser.add_argument('--version', action='version', version='%(prog)s 0.3.2')
+    parser.add_argument('-o', '--out', help="Path to output directory ['out_dir'].", default="out_dir")
+    parser.add_argument('-g', '--genome', help="Path to the reference genome.")
+    parser.add_argument('-v', '--vcf', nargs='+',
+                        help="Path(s) to VCF file(s). For simulation/align/single-run analyze, "
+                             "provide exactly one. For multi-report analyze, you may provide "
+                             "one VCF shared by all reports or one per report.")
+    parser.add_argument('-s', '--sample_id', help="Sample ID ['sample'].", default="sample")
+    parser.add_argument('-r', '--run_id', help="Run ID ['run'].", default="run")
+    # Process options
+    parser.add_argument('--simulate', help='[1] Option to run biastools simulation.', action='store_true')
+    parser.add_argument('--align',    help='[2] Option to run biastools align.', action='store_true')
+    parser.add_argument('--analyze',  help='[3] Option to run biastools analyze.', action='store_true')
+    parser.add_argument('--predict',  help='[4] Option to predict bias from analysis report.', action='store_true')
+
+    parser.add_argument('-t', '--thread', help="Number of threads to use [max].", type=int)
+    parser.add_argument('--force', help="running the program without checking prerequisite programs.", action='store_true')
+    # [1]
+    parser.add_argument('-x', '--coverage', help="Read coverage to simulate [30].", type=int, default=30)
+    # [2]
+    parser.add_argument('-a', '--aligner', help="Aligner to use (bowtie2|bwamem) [bowtie2]", default="bowtie2")
+    parser.add_argument('-b', '--align_index', help="Path to the aligner index (target reference)")
+    # [3]
+    parser.add_argument('-i', '--bam', help="Path to the alignment bam file, should be sorted [out_dir/sample.run_id.sorted.bam].")
+    parser.add_argument('-n', '--naive', help= "Option to run the naive assignment method [False].", action='store_true')
+    parser.add_argument('-R', '--real',  help= "Option for performing analysis on real data [False].", action='store_true')
+    parser.add_argument('-d', '--boundary', help= "Boundary to plot the indel balance plot [20]", type=int, default=20)
+    parser.add_argument('-lr', '--list_report', help= "List of bias report to plot the indel balance plot", nargs='+')
+    parser.add_argument('-ld', '--list_run_id', help= "List of run ID for namings in the indel balance plot", nargs='+')
+    # [4]
+    parser.add_argument('-ps', '--sim_report',  help= "Path to the simulation report.")
+    parser.add_argument('-pr', '--real_report', help= "Path to the real read report  [out_dir/sample.real.run.bias].")
+    args = parser.parse_args()
+    
+    ##### Parameters for biastool_analysis
+    path_output = args.out
+    path_ref    = args.genome
+    vcf_list    = args.vcf  # may be None or a list of one/many paths
+    # For steps that only support a single VCF (simulate/align/single-run analyze),
+    # use the first entry when provided.
+    path_vcf    = vcf_list[0] if vcf_list else None
+    sample_id   = args.sample_id
+    run_id      = args.run_id
+    bam_file    = args.bam
+    if bam_file == None:
+        bam_file = path_output + '/' + sample_id + '.' + run_id + '.sorted.bam'
+    
+    flag_simulate = args.simulate
+    flag_align    = args.align
+    flag_analyze  = args.analyze
+    flag_predict  = args.predict
+
+    path_module = os.path.dirname(__file__) + '/'
+    try:
+        assert flag_simulate + flag_align + flag_analyze + flag_predict >= 1 
+    except AssertionError:
+        catch_assert(parser, "At least one of the --simulate/align/analyze/predict option should be specified.")
+
+    flag_force = args.force
+    thread = args.thread
+    if thread == None:
+        if sys.platform == "darwin":
+            result = subprocess.run(["sysctl -n hw.ncpu"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+        else:
+            result = subprocess.run(["nproc"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+        thread = int(result.stdout.strip())
+    
+    coverage = args.coverage
+    aligner  = args.aligner
+    align_index = args.align_index
+    try:
+        assert aligner=="bowtie2" or aligner=="bwamem" 
+    except AssertionError:
+        catch_assert(parser, "Only bowtie2 and bwamem are supported.")
+
+    flag_naive  = args.naive
+    flag_real   = args.real
+    boundary    = args.boundary
+    list_report = args.list_report
+    list_run_id = args.list_run_id
+    if list_report:
+        try:
+            assert len(list_report) == len(list_run_id)
+        except AssertionError:
+            catch_assert(parser, "Number of list --list_report and --list_run_id entries are inconsistent.")
+
+    # Multiple VCF paths are only meaningful for multi-report analyze mode,
+    # where each bias report can have its own VCF. For all other modes, require
+    # at most one VCF path.
+    if vcf_list and len(vcf_list) > 1:
+        if not (flag_analyze and list_report):
+            catch_assert(
+                parser,
+                "Multiple --vcf paths are only supported when using --analyze "
+                "together with --list_report/--list_run_id.",
+            )
+
+    sim_report  = args.sim_report
+    real_report = args.real_report
+    if flag_predict: 
+        try:
+            assert real_report != None
+        except AssertionError:
+            catch_assert(parser, "<real_report> should be specified when using --predict")
+
+
+    
+    # Checking prerequisite programs are installed
+    if flag_force != True:
+        list_program = ["bedtools", \
+                         "samtools", \
+                         "bcftools", \
+                         "gzip", \
+                         "tabix"]
+        if flag_align:
+            list_program += ["bwa", "bowtie2"]
+        if flag_simulate:
+            list_program.append("mason_simulator")
+        check_program_install( list_program ) 
+
+    # Start running
+    command = "mkdir -p " + path_output
+    subprocess.call(command, shell=True)
+
+    if flag_simulate:
+        try:
+            assert path_ref != None
+            assert path_vcf != None 
+        except AssertionError:
+            catch_assert(parser, "<genome> and <vcf> should be specified when using --simulate")
+        print("[Biastools] Simulate...")
+        command = ' '.join(["bash", path_module+"biastools_simulation.sh", path_ref, path_vcf, path_output, sample_id, str(thread), str(coverage), path_module])
+        #print(command)
+        subprocess.call(command, shell=True)
+    if flag_align:
+        try:
+            assert path_ref != None
+            assert path_vcf != None
+        except AssertionError:
+            catch_assert(parser, "<genome> and <vcf> should be specified when using --align")
+        if align_index == None:
+            align_index = path_ref
+        print("[Biastools] Align...")
+        command = ' '.join(["bash", path_module+"biastools_align.sh", path_ref, path_vcf, path_output, sample_id, str(thread), aligner, align_index, run_id, path_module])
+        #print(command)
+        subprocess.call(command, shell=True)
+    if flag_analyze:
+        if list_report != None:
+            # Multi-report indel balance plotting.
+            # If multiple VCFs are provided, pass them directly through to
+            # indel_balance_plot.py, one per report. Otherwise, ensure the
+            # processed VCF for this sample exists and use it for all reports.
+            if vcf_list and len(vcf_list) > 1:
+                if len(vcf_list) != len(list_report):
+                    catch_assert(
+                        parser,
+                        "When providing multiple --vcf paths, their number must "
+                        "match the number of --list_report entries.",
+                    )
+                vcf_args = ["-vcf"] + vcf_list
+            else:
+                # Ensure the processed VCF exists (or regenerate it) before plotting.
+                het_vcf_path = ensure_processed_vcf(
+                    path_ref=path_ref,
+                    path_vcf=path_vcf,
+                    path_output=path_output,
+                    sample_id=sample_id,
+                    path_module=path_module,
+                    parser=parser,
+                )
+                vcf_args = ["-vcf", het_vcf_path]
+
+            print("[Biastools] Plot the indel balance plot for multiple bias reports...")
+            if flag_real:
+                subprocess.call(
+                    ['python3', path_module+'indel_balance_plot.py', "-lr"] + list_report
+                    + ["-ln"] + list_run_id
+                    + vcf_args
+                    + ["-bd", str(boundary), "-map",
+                       "-out", path_output+"/"+sample_id+"."+run_id+".real", "-real"]
+                )
+            else:
+                subprocess.call(
+                    ['python3', path_module+'indel_balance_plot.py', "-lr"] + list_report
+                    + ["-ln"] + list_run_id
+                    + vcf_args
+                    + ["-bd", str(boundary), "-map",
+                       "-out", path_output+"/"+sample_id+"."+run_id+".sim"]
+                )
+        else:
+            try:
+                assert path_ref != None
+                assert path_vcf != None
+            except AssertionError:
+                catch_assert(parser, "<genome> and <vcf> should be specified when using --analyze")
+            # When running analyze directly, ensure that the BAM file is either
+            # explicitly provided or present at the default location.
+            if not os.path.exists(bam_file):
+                catch_assert(
+                    parser,
+                    "BAM file not found. Please specify --bam <file> explicitly "
+                    "or ensure it exists at the default path: "
+                    f"{path_output}/{sample_id}.{run_id}.sorted.bam",
+                )
+            print("[Biastools] Analyze and plot...")
+            command = ' '.join(["bash", path_module+"biastools_analysis.sh", path_ref, path_vcf, path_output, sample_id, str(thread), run_id, bool2str(flag_real), \
+                                bool2str(flag_naive), str(boundary), path_module, bam_file])
+            #print(command)
+            subprocess.call(command, shell=True)
+    if flag_predict:
+        print("[Biastools] Predict bias...")
+        command = ' '.join(["bash", path_module+"biastools_predict.sh", path_output, sample_id, run_id, bool2str(flag_real), real_report, sim_report, path_module])
+        #print(command)
+        subprocess.call(command, shell=True)
+
+
+
+
+    
+if __name__ == "__main__":
+    main()
+
+
+
+    

biastools/biastools_align.sh

@@ -0,0 +1,38 @@
+path_ref=$1
+path_vcf=$2
+path_out=$3
+sample_id=$4
+THR=$5
+ALN=$6
+ALN_IDX=$7
+run_id=$8
+path_module=$9
+prefix=${path_out}/${sample_id}
+
+echo "[Biastools] Align sequences to the original reference"
+if [[ ${ALN_IDX} == 'none' ]]; then
+    ALN_IDX=${path_ref}
+fi
+
+if [[ ${ALN} == "bowtie2" ]]; then
+    echo "[Biastools] Align with bowtie2"
+    if [ ! -f ${ALN_IDX}.1.bt2 ]; then
+        bowtie2-build ${path_ref} ${ALN_IDX}
+    fi
+    bowtie2 -p ${THR} -x ${ALN_IDX} --rg-id ${run_id}_hapA --rg SM:${sample_id} -1 ${prefix}.hapA_1.fq.gz -2 ${prefix}.hapA_2.fq.gz |\
+        samtools sort -o ${prefix}.hapA.${run_id}.sorted.bam  
+    bowtie2 -p ${THR} -x ${ALN_IDX} --rg-id ${run_id}_hapB --rg SM:${sample_id} -1 ${prefix}.hapB_1.fq.gz -2 ${prefix}.hapB_2.fq.gz |\
+        samtools sort -o ${prefix}.hapB.${run_id}.sorted.bam 
+elif [[ ${ALN} == "bwamem" ]]; then
+    echo "[Biastools] Align with BWA MEM"
+    if [ ! -f ${ALN_IDX}.bwt ]; then
+        bwa index ${path_ref} -p ${ALN_IDX}
+    fi
+    bwa mem -t ${THR} ${ALN_IDX} ${prefix}.hapA_1.fq.gz ${prefix}.hapA_2.fq.gz -R "@RG\tID:${run_id}_hapA\tSM:${sample_id}" |\
+        samtools sort -@ ${THR} -o ${prefix}.hapA.${run_id}.sorted.bam -
+    bwa mem -t ${THR} ${ALN_IDX} ${prefix}.hapB_1.fq.gz ${prefix}.hapB_2.fq.gz -R "@RG\tID:${run_id}_hapB\tSM:${sample_id}" |\
+        samtools sort -@ ${THR} -o ${prefix}.hapB.${run_id}.sorted.bam -
+fi
+samtools merge -f ${prefix}.${run_id}.sorted.bam ${prefix}.hapA.${run_id}.sorted.bam ${prefix}.hapB.${run_id}.sorted.bam
+
+

biastools/biastools_analysis.sh

@@ -0,0 +1,73 @@
+path_ref=$1
+path_vcf=$2
+path_out=$3
+sample_id=$4
+THR=$5
+run_id=$6
+flag_real=$7
+flag_naive=$8
+boundary=$9
+path_module=${10}
+prefix=${path_out}/${sample_id}
+bam_file=${11}
+
+
+echo "[Biastools] Intersect the bam file and vcf file"
+if [ ! -f ${prefix}.het.vcf.gz ]; then
+    bcftools norm -f ${path_ref} ${path_vcf} -m +any -Oz -o ${prefix}.normalized.vcf.gz
+    bcftools index ${prefix}.normalized.vcf.gz
+    python3 ${path_module}filter_het_VCF.py -v ${prefix}.normalized.vcf.gz  -o ${prefix}.het.vcf.gz
+    tabix -p vcf ${prefix}.het.vcf.gz
+fi
+if [ ! -f ${prefix}.${run_id}.sorted.het.bam ]; then
+    python3 ${path_module}vcf_to_bed.py -v ${prefix}.het.vcf.gz -o ${prefix}.het.bed
+    samtools view -h -L ${prefix}.het.bed ${bam_file} -@ ${THR} | samtools sort -@ ${THR} > ${prefix}.${run_id}.sorted.het.bam
+    samtools index ${prefix}.${run_id}.sorted.het.bam
+fi
+
+
+echo "[Biastools] Reference bias analysis"
+if [[ ${flag_naive} == 1 ]]; then
+    assign_method=${path_module}"ref_bi_naive.py"
+else
+    assign_method=${path_module}"ref_bi_context.py"
+fi
+
+mkdir -p ${path_out}/${run_id}"_report"
+r_prefix=${path_out}/${run_id}"_report"/${sample_id}
+if [[ ${flag_real} == 1 ]]; then
+    python3 ${assign_method} -s ${prefix}.${run_id}.sorted.het.bam \
+                             -v ${prefix}.het.vcf.gz \
+                             -f ${path_ref} \
+                             -p ${prefix}.golden.rpt.pickle \
+                             -o ${r_prefix}.${run_id}.real.bias \
+                             --real
+    # indel balance plot
+    python3 ${path_module}indel_balance_plot.py  -lr ${r_prefix}.${run_id}.real.bias.all \
+                                             -ln ${run_id} \
+                                             -vcf ${prefix}.het.vcf.gz \
+                                             -bd ${boundary} \
+                                             -map \
+                                             -out ${r_prefix}.${run_id}.real \
+                                             -real
+else
+    python3 ${assign_method} -s ${prefix}.${run_id}.sorted.het.bam \
+                             -v ${prefix}.het.vcf.gz \
+                             -f ${path_ref} \
+                             -p ${prefix}.golden.rpt.pickle \
+                             -o ${r_prefix}.${run_id}.sim.bias
+    
+    # report the bias categories and report
+    python3 ${path_module}golden_graph_report.py -mb ${r_prefix}.${run_id}.sim.bias.snp -out ${r_prefix}.${run_id}.snp
+    python3 ${path_module}golden_graph_report.py -mb ${r_prefix}.${run_id}.sim.bias.gap -out ${r_prefix}.${run_id}.gap
+    # plot the measures with NMB and NAB                      
+    python3 ${path_module}golden_graph.py        -mb ${r_prefix}.${run_id}.sim.bias.snp -out ${r_prefix}.${run_id}.snp
+    python3 ${path_module}golden_graph.py        -mb ${r_prefix}.${run_id}.sim.bias.gap -out ${r_prefix}.${run_id}.gap
+    # indel balance plot
+    python3 ${path_module}indel_balance_plot.py  -lr ${r_prefix}.${run_id}.sim.bias.all \
+                                                 -ln ${run_id} \
+                                                 -vcf ${prefix}.het.vcf.gz \
+                                                 -bd ${boundary} \
+                                                 -map \
+                                                 -out ${r_prefix}.${run_id}.sim
+fi

biastools/biastools_compare.sh

@@ -0,0 +1,14 @@
+path_out=$1
+sample_id=$2
+run_id=$3
+target_bed=$4
+improve_bed=$5
+improve_lowRd=$6
+path_module=$7
+prefix=${path_out}/${sample_id}
+
+bedtools subtract  -a ${improve_bed} -b ${improve_lowRd} > ${prefix}.improve.goodRd.bias.bed
+bedtools intersect -a ${target_bed}  -b ${improve_lowRd} > ${prefix}.improve.skipped.bias.bed
+
+python3 ${path_module}compare_bias_with_RD.py -lt ${target_bed} -li ${prefix}.improve.goodRd.bias.bed -lrd ${prefix}.improve.skipped.bias.bed -out ${prefix}.${run_id}.improve.bias.bed
+#python3 check_inside_centromere.py -lr1 centromere_extend.bed -lr2 ${prefix}.${run_id}.improve.bias.bed

biastools/biastools_predict.sh

@@ -0,0 +1,23 @@
+path_out=$1
+sample_id=$2
+run_id=$3
+flag_real=$4
+report_real=$5
+report_simulation=$6
+path_module=$7
+prefix=${path_out}/${sample_id}
+
+
+if [[ ${report_real} == 'none' ]]; then
+    report_real=${prefix}.real.${run_id}.bias
+fi
+
+if [[ ${flag_real} == 1 || ${report_simulation} == 'none' ]]; then
+    echo "[Biastools] Real report bias prediction."
+    python3 ${path_module}predict_model.py -rr ${report_real} -out ${prefix}.real.${run_id}
+else
+    echo "[Biastools] Bias prediction based on simulation report!"
+    python3 ${path_module}predict_experiment.py -sr ${report_simulation} \
+                                                -rr ${report_real} \
+                                                -out ${prefix}.sim.${run_id}
+fi

biastools/biastools_scan.py

@@ -0,0 +1,165 @@
+# Wrap up python file for the biastools 3rd module
+import subprocess
+import sys
+import os
+import argparse
+from biastools.biastools import check_program_install, catch_assert
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-o', '--out', help="Path to output directory ['out_dir'].", default="out_dir")
+    parser.add_argument('-g', '--genome', help="Path to the reference genome.")
+    parser.add_argument('-i', '--bam', help="Path to the alignment bam file, should be SORTED.")
+    parser.add_argument('-s', '--sample_id', help="Sample ID ['sample'].", default="sample")
+    parser.add_argument('-r', '--run_id', help="Run ID ['run'].", default="run")
+    # Process options
+    parser.add_argument('--scan',        help='[1] Option to scan and report bias region.', action='store_true')
+    parser.add_argument('--compare_bam', help='[2] Option to generate common baseline and compare.', action='store_true')
+    parser.add_argument('--compare_rpt', help='[3] Option to directly compare two bias report.', action='store_true')
+
+    parser.add_argument('-t', '--thread', help="Number of threads to use [max].", type=int)
+    parser.add_argument('--force', help="running the program without checking prerequisite programs.", action='store_true')
+    # [1]
+    parser.add_argument('-w', '--wig', help="Generate the wig files for the three measures, VERY SLOW [False]", action='store_true')
+    parser.add_argument('-R', '--range', help="The range in the bam file targeted for analysis.")
+    # [2]
+    parser.add_argument('-i2', '--bam2',     help="Path to the second alignment bam file want to compare, should be SORTED.")
+    parser.add_argument('-m',  '--mpileup',  help="Path to the mpileup file of the first bam file.")
+    parser.add_argument('-m2', '--mpileup2', help="Path to the mpileup file of the second bam file.")
+    # [3]
+    parser.add_argument('-b1', '--bed1', help="Path to the first bed file for comparison.")
+    parser.add_argument('-b2', '--bed2', help="Path to the second bed file for comparison.")
+    parser.add_argument('-l2', '--lowRd2', help="Path to the .lowRd.bed report of the second file.")
+    args = parser.parse_args()
+    
+    path_output = args.out
+    path_ref   = args.genome
+    bam_file   = args.bam
+    sample_id  = args.sample_id
+    run_id     = args.run_id
+    
+    flag_scan        = args.scan
+    flag_compare_bam = args.compare_bam
+    flag_compare_rpt = args.compare_rpt
+    try:
+        assert flag_scan + flag_compare_bam + flag_compare_rpt >= 1 
+    except AssertionError:
+        catch_assert(parser, "At least one of the --scan/compare_bam/compare_rpt option should be specified.")
+
+    flag_force = args.force
+    thread = args.thread
+    if thread == None:
+        if sys.platform == "darwin":
+            result = subprocess.run(["sysctl -n hw.ncpu"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+        else:
+            result = subprocess.run(["nproc"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True)
+        thread = int(result.stdout.strip())
+    flag_wig  = args.wig
+    Range     = args.range 
+    bam_file2 = args.bam2
+    mpileup_file = args.mpileup
+    mpileup_file2 = args.mpileup2
+    bed_file1 = args.bed1
+    bed_file2 = args.bed2
+    lowRd_file2 = args.lowRd2
+
+    
+    # Checking prerequisite programs are installed
+    if flag_force != True:
+        check_program_install(["bedtools", \
+                               "samtools", \
+                               "bcftools"])
+
+    # Start running
+    command = "mkdir -p " + path_output
+    subprocess.call(command, shell=True)
+    prefix = path_output + '/' + sample_id 
+    path_module = os.path.dirname(__file__) + '/'
+    if flag_scan:
+        print("[Biastools] Scanning...")
+        if os.path.exists(bam_file+'.bai'):
+            pass
+        else:
+            command = ["samtools", "index", bam_file]
+            subprocess.call(command)
+        
+        print("[BIASTOOLS] SAMPLE", bam_file, " as ", sample_id + ".baseline ...")
+        command = ["python3", path_module+"sample_baseline.py", "-b", bam_file, "-f", path_ref, "-o", prefix+".sample"]
+        print(' '.join(command))
+        subprocess.call(command)
+        
+        if Range == None:
+            print("[BIASTOOLS] Process the whole bam file...")
+            target_bam = bam_file
+        else:
+            print("[BIASTOOLS] Extract reads from " + Range + "...")
+            target_bam = prefix + '.range.bam'
+            command = ["samtools", "view", " -h", bam_file, Range, "-o", target_bam, "-@", thread]
+            print(' '.join(command))
+            subprocess.call(command)
+
+        print("[BIASTOOLS] Format the mpileup...")
+        if os.path.exists(prefix+'.'+run_id+'.mpileup'):
+            print(prefix+'.'+run_id+'.mpileup already exist!')
+        else:
+            command = ["bcftools", "mpileup", "--count-orphans", "--annotate", "FORMAT/AD,FORMAT/DP", \
+                       "-f", path_ref, \
+                       "--min-BQ", "0", \
+                       "--min-MQ", "0", \
+                       "--threads", str(thread), target_bam, "-o", prefix+'.'+run_id+'.mpileup']
+            print(' '.join(command))
+            subprocess.call(command)
+        print("[BIASTOOLS] Scanning bias...")
+        if flag_wig:
+            command = ["python3", path_module+"scanning_bias.py", "-g", prefix+'.'+run_id+'.mpileup', "--sample", "-b", prefix+".sample.baseline", \
+                       "-wig", "-o", prefix+'.'+run_id+'.scanning']
+        else:
+            command = ["python3", path_module+"scanning_bias.py", "-g", prefix+'.'+run_id+'.mpileup', "--sample", "-b", prefix+".sample.baseline", \
+                       "-o", prefix+'.'+run_id+'.scanning']
+        print(' '.join(command))
+        subprocess.call(command)
+    
+    if flag_compare_bam:
+        if os.path.exists(bam_file+'.bai'):
+            pass
+        else:
+            command = ["samtools", "index", bam_file]
+            subprocess.call(command)
+        if os.path.exists(bam_file2+'.bai'):
+            pass
+        else:
+            command = ["samtools", "index", bam_file2]
+            subprocess.call(command)
+
+        print("[Biastools] Generate common baseline...")
+        baseline = prefix+"."+run_id+".combine"
+        command = ["python3", path_module+"merge_baseline.py", "-b1", bam_file, "-b2", bam_file2, "-f", path_ref, "-o", baseline]
+        #print(' '.join(command))
+        subprocess.call(command)
+        command = ' '.join(["python3", path_module+"scanning_bias.py", "-g", mpileup_file,  "-b", baseline+".baseline", "-o", baseline+".1.scanning", ">", prefix+"."+run_id+".log"])
+        #print(command)
+        subprocess.call(command, shell=True)
+        command = ' '.join(["python3", path_module+"scanning_bias.py", "-g", mpileup_file2, "-b", baseline+".baseline", "-o", baseline+".2.scanning", ">", prefix+"."+run_id+".log"])
+        #print(command)
+        subprocess.call(command, shell=True)
+
+        print("[Biastools] Compare two bam files with common baseline...")
+        command = ' '.join(["bash", path_module+"biastools_compare.sh", path_output, sample_id, run_id, \
+                            baseline+".1.scanning.bias.bed", \
+                            baseline+".2.scanning.bias.bed", \
+                            baseline+".2.scanning.lowRd.bed", \
+                            path_module])
+        print(command)
+        subprocess.call(command, shell=True)
+    if flag_compare_rpt:
+        print("[Biastools] Compare two bed files...")
+        command = ' '.join(["bash", path_module+"biastools_compare.sh", path_output, sample_id, run_id, bed_file1, bed_file2, lowRd_file2, path_module])
+        print(command)
+        subprocess.call(command, shell=True)
+
+
+
+
+if __name__ == "__main__":
+    main()