Cleaning transcriptome annotations with ab initio assemblers

public 1yr ago 0 bookmarks

View Workflow

Introduction

AnnotationCleaner is designed to automate the construction of ab initio assembled transcriptomes using several different tools. This will allow you to test the impact of assembler choice on downstream applications. Currently, the a

Code Snippets

wrapper:
    "v2.1.1/bio/samtools/sort"

SnakeMake From line 91 of rules/common.smk

shell:
    """
    portcullis prep -t {threads} -o prepare_portcullis {params.extra_prep} {input.fasta} {input.bams} 1> {log} 2>&1
    portcullis junc -t {threads} --orientation {params.orientation} \
    --strandedness {params.strandedness} -o results/identify_junctions/junctions {params.extra_junc} \
    prepare_portcullis/ 1> {log} 2>&1
    """

SnakeMake portcullis From line 19 of rules/mikado.smk

shell:
    """
    mikado configure --list {input.mlist} --scoring {params.scoring} --reference {input.reference} \
    --junctions {input.junctions} -bt {input.proteins} -od results/mikado_configure/ {params.extra} -t {threads} {output} 1> {log} 2>&1
    """  

SnakeMake Mikado From line 46 of rules/mikado.smk

shell:
    "mikado prepare --json-conf {input} -od results/mikado_prepare/ {params.extra} 1> {log} 2>&1"

SnakeMake Mikado From line 67 of rules/mikado.smk

shell:
    """
    TransDecoder.LongOrfs -t {input.fasta} --output_dir results/identify_orfs/ {params.extra} 2> {log}
    """

SnakeMake TransDecoder From line 84 of rules/mikado.smk

shell:
    """
    TransDecoder.Predict -t {input.transcripts} --output_dir results/identify_orfs/ 2> {log}
    """

SnakeMake From line 102 of rules/mikado.smk

shell:
    """
    makeblastdb -in {input.proteins} -dbtype prot -parse_seqids {params.extra} -out results/mikado_blastdb/mikado_blastdb 1> {log} 2>&1
    """

SnakeMake From line 122 of rules/mikado.smk

shell:
    """
    pyfasta split -n {params.nsub} {input.fasta}
    """

SnakeMake pyfasta From line 142 of rules/mikado.smk

shell:
    """
    blastx {params.extra} -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore ppos btop" \
    -num_threads {threads} -query {input.fasta} -db results/mikado_blastdb/mikado_blastdb -out {output.mikado_blast} 2> {log}
    """

SnakeMake From line 160 of rules/mikado.smk

shell:
    """
    mikado serialise --json-conf {input.mconfig} --transcripts {input.transcripts} --orfs {input.orfs} -od results/mikado_serialise/ \
    --junctions {input.junctions} -p {threads} --tsv results/mikado_blast/ --blast_targets {input.blast_db} {params.extra} 1> {log} 2>&1
    """

SnakeMake Mikado From line 184 of rules/mikado.smk

shell:
    """
    blastx {params.extra} -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore ppos btop" \
    -num_threads {threads} -query {input.fasta} -db results/mikado_blastdb/mikado_blastdb -out {output.mikado_blast} 2> {log}
    """

SnakeMake From line 220 of rules/mikado.smk

shell:
    """
    mikado serialise --json-conf {input.mconfig} --transcripts {input.transcripts} --orfs {input.orfs} -od results/mikado_serialise/ \
    --junctions {input.junctions} --tsv {input.blast} --blast_targets {input.blast_db} {params.extra} 1> {log} 2>&1
    """

SnakeMake Mikado From line 247 of rules/mikado.smk

shell:
    "mikado pick --configuration {input.mconfig} -db {input.db} --loci_out mikado.loci.gff3 --subloci_out mikado.subloci.gff3 -od results/mikado_pick/ {params.extra} 1> {log} 2>&1"

SnakeMake Mikado From line 269 of rules/mikado.smk

shell:
    """
    mikado compare -r {input.reference} --index 1> {log} 2>&1
    mikado compare -r {input.reference} -p {input.mikado_out} -o results/mikado_compare/compare 1> {log} 2>&1
    touch {output.dummy}
    """

SnakeMake Mikado From line 285 of rules/mikado.smk

run:

    scallop = params.scallop
    stringtie = params.stringtie
    provided_annotations = params.provided_annotations

    with open(output[0], 'w') as f:

        if scallop["use_scallop"]:

            scallop.pop("use_scallop")
            taco = scallop.pop("use_taco")
            paths = SCALLOP_PATHS

            counter = 1
            for p in paths:

                row = [str(value) for value in scallop.values()]

                row.insert(0, str(p))

                row[1] = row[1] + str(counter)
                counter = counter + 1

                f.write('\t'.join(row) + '\n')

        if stringtie["use_stringtie"]:

            stringtie.pop("use_stringtie")
            taco = stringtie.pop("use_taco")
            merge = stringtie.pop("use_merge")
            paths = STRINGTIE_PATHS

            counter = 1
            for p in paths:

                row = [str(value) for value in stringtie.values()]

                row.insert(0, str(p))

                row[1] = row[1] + str(counter)
                counter = counter + 1

                f.write('\t'.join(row) + '\n')


        if ~bool(provided_annotations):

            for key, inner_dict in provided_annotations.items():

                row = [str(value) for value in inner_dict.values()]

                row.insert(1, key)

                f.write('\t'.join(row) + '\n')

SnakeMake StringTie From line 305 of rules/mikado.smk

shell:
    "scallop -i {input} -o {output.gtf} {params.extra} 1> {log} 2>&1"

SnakeMake From line 13 of rules/scallop.smk

run:
    with open(output[0], "w") as file:
        for path in input:
            file.write(path + "\n")

SnakeMake From line 22 of rules/scallop.smk

shell:
    """
    taco_run -o ./results/scallop_taco/ -p {threads} {params.extra_taco} {input} 1> {log} 2>&1
    taco_refcomp -o ./results/scallop_taco_refcomp/ -r {params.gtf} -t ./results/scallop_taco/assembly.gtf {params.extra_refcomp} 1> {log} 2>&1
    touch {output.output_dummy}
    """

SnakeMake taco From line 41 of rules/scallop.smk

shell:
    "stringtie -o {output} -p {threads} -G {params.gtf} {params.extra} {input} 1> {log} 2>&1"

SnakeMake StringTie From line 14 of rules/stringtie.smk

shell:
    "stringtie --merge -p {threads} -G {params.gtf} -o {output} {params.extra} {input}"

SnakeMake StringTie From line 30 of rules/stringtie.smk

run:
    with open(output[0], "w") as file:
        for path in input:
            file.write(path + "\n")

SnakeMake From line 39 of rules/stringtie.smk

shell:
    """
    taco_run -o ./results/stringtie_taco/ -p {threads} {params.extra_taco} {input} 1> {log} 2>&1
    taco_refcomp -o ./results/stringtie_taco_refcomp/ -r {params.gtf} -t ./results/stringtie_taco/assembly.gtf {params.extra_refcomp} 1> {log} 2>&1
    touch {output.output_dummy}
    """

SnakeMake taco From line 58 of rules/stringtie.smk

__author__ = "Johannes Köster"
__copyright__ = "Copyright 2016, Johannes Köster"
__email__ = "koester@jimmy.harvard.edu"
__license__ = "MIT"


import tempfile
from pathlib import Path
from snakemake.shell import shell
from snakemake_wrapper_utils.snakemake import get_mem
from snakemake_wrapper_utils.samtools import get_samtools_opts


samtools_opts = get_samtools_opts(snakemake)
extra = snakemake.params.get("extra", "")
log = snakemake.log_fmt_shell(stdout=True, stderr=True)

mem_per_thread_mb = int(get_mem(snakemake) / snakemake.threads)

with tempfile.TemporaryDirectory() as tmpdir:
    tmp_prefix = Path(tmpdir) / "samtools_sort"

    shell(
        "samtools sort {samtools_opts} -m {mem_per_thread_mb}M {extra} -T {tmp_prefix} {snakemake.input[0]} {log}"
    )