shell:
    """
    # Activate metagem environment
    echo -e "Activating {config[envs][metagem]} conda environment ... "
    set +u;source activate {config[envs][metagem]};set -u;

    # This is just to make sure that output folder exists
    mkdir -p $(dirname {output.R1})

    # Make job specific scratch dir
    idvar=$(echo $(basename $(dirname {output.R1}))|sed 's/_R1.fastq.gz//g')
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][qfiltered]}/${{idvar}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][qfiltered]}/${{idvar}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][qfiltered]}/${{idvar}}

    # Copy files
    echo -e "Copying {input.R1} and {input.R2} to {config[path][scratch]}/{config[folder][qfiltered]}/${{idvar}} ... "
    cp {input.R1} {input.R2} .

    echo -e "Appending .raw to temporary input files to avoid name conflict ... "
    for file in *.gz; do mv -- "$file" "${{file}}.raw.gz"; done

    # Run fastp
    echo -n "Running fastp ... "
    fastp --thread {config[cores][fastp]} \
        -i *R1*raw.gz \
        -I *R2*raw.gz \
        -o $(basename {output.R1}) \
        -O $(basename {output.R2}) \
        -j $(dirname {output.R1})/$(echo $(basename $(dirname {output.R1}))).json \
        -h $(dirname {output.R1})/$(echo $(basename $(dirname {output.R1}))).html

    # Move output files to root dir
    echo -e "Moving output files $(basename {output.R1}) and $(basename {output.R2}) to $(dirname {output.R1})"
    mv $(basename {output.R1}) $(basename {output.R2}) $(dirname {output.R1})

    # Warning
    echo -e "Note that you must manually clean up these temporary directories if your scratch directory points to a static location instead of variable with a job specific location ... "

    # Done message
    echo -e "Done quality filtering sample ${{idvar}}"
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Make sure that output folder exists
    mkdir -p $(dirname {output})

    # Make job specific scratch dir
    idvar=$(echo $(basename $(dirname {output})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][assemblies]}/${{idvar}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][assemblies]}/${{idvar}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][assemblies]}/${{idvar}}

    # Copy files
    echo -n "Copying qfiltered reads to {config[path][scratch]}/${{idvar}} ... "
    cp {input.R1} {input.R2} .
    echo "done. "

    # Run megahit
    echo -n "Running MEGAHIT ... "
    megahit -t {config[cores][megahit]} \
        --presets {config[params][assemblyPreset]} \
        --verbose \
        --min-contig-len {config[params][assemblyMin]} \
        -1 $(basename {input.R1}) \
        -2 $(basename {input.R2}) \
        -o tmp;
    echo "done. "

    # Rename assembly
    echo "Renaming assembly ... "
    mv tmp/final.contigs.fa contigs.fasta

    # Remove spaces from contig headers and replace with hyphens
    echo "Fixing contig header names: replacing spaces with hyphens ... "
    sed -i 's/ /-/g' contigs.fasta

    # Zip and move assembly to output folder
    echo "Zipping and moving assembly ... "
    gzip contigs.fasta
    mv contigs.fasta.gz $(dirname {output})

    # Done message
    echo -e "Done assembling quality filtered reads for sample ${{idvar}}"
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Create output folders
    mkdir -p {output.concoct}
    mkdir -p {output.metabat}
    mkdir -p {output.maxbin}

    # Make job specific scratch dir
    idvar=$(echo $(basename $(dirname {output.concoct})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][crossMap]}/${{idvar}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][crossMap]}/${{idvar}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][crossMap]}/${{idvar}}

    # Copy files
    cp {input.contigs} .

    # Define the focal sample ID, fsample: 
    # The one sample's assembly that all other samples' read will be mapped against in a for loop
    fsampleID=$(echo $(basename $(dirname {input.contigs})))
    echo -e "\nFocal sample: $fsampleID ... "

    echo "Renaming and unzipping assembly ... "
    mv $(basename {input.contigs}) $(echo $fsampleID|sed 's/$/.fa.gz/g')
    gunzip $(echo $fsampleID|sed 's/$/.fa.gz/g')

    echo -e "\nIndexing assembly ... "
    bwa index $fsampleID.fa

    for folder in {input.reads}/*;do 

            id=$(basename $folder)

            echo -e "\nCopying sample $id to be mapped against the focal sample $fsampleID ..."
            cp $folder/*.gz .

            # Maybe I should be piping the lines below to reduce I/O ?

            echo -e "\nMapping sample to assembly ... "
            bwa mem -t {config[cores][crossMap]} $fsampleID.fa *.fastq.gz > $id.sam

            echo -e "\nConverting SAM to BAM with samtools view ... " 
            samtools view -@ {config[cores][crossMap]} -Sb $id.sam > $id.bam

            echo -e "\nSorting BAM file with samtools sort ... " 
            samtools sort -@ {config[cores][crossMap]} -o $id.sort $id.bam

            echo -e "\nRunning jgi_summarize_bam_contig_depths script to generate contig abundance/depth file for maxbin2 input ... "
            jgi_summarize_bam_contig_depths --outputDepth $id.depth $id.sort

            echo -e "\nMoving depth file to sample $fsampleID maxbin2 folder ... "
            mv $id.depth {output.maxbin}

            echo -e "\nIndexing sorted BAM file with samtools index for CONCOCT input table generation ... " 
            samtools index $id.sort

            echo -e "\nRemoving temporary files ... "
            rm *.fastq.gz *.sam *.bam

    done

    nSamples=$(ls {input.reads}|wc -l)
    echo -e "\nDone mapping focal sample $fsampleID agains $nSamples samples in dataset folder."

    echo -e "\nRunning jgi_summarize_bam_contig_depths for all sorted bam files to generate metabat2 input ... "
    jgi_summarize_bam_contig_depths --outputDepth $id.all.depth *.sort

    echo -e "\nMoving input file $id.all.depth to $fsampleID metabat2 folder... "
    mv $id.all.depth {output.metabat}

    echo -e "Done. \nCutting up contigs to 10kbp chunks (default), not to be used for mapping!"
    cut_up_fasta.py -c {config[params][cutfasta]} -o 0 -m $fsampleID.fa -b assembly_c10k.bed > assembly_c10k.fa

    echo -e "\nSummarizing sorted and indexed BAM files with concoct_coverage_table.py to generate CONCOCT input table ... " 
    concoct_coverage_table.py assembly_c10k.bed *.sort > coverage_table.tsv

    echo -e "\nMoving CONCOCT input table to $fsampleID concoct folder"
    mv coverage_table.tsv {output.concoct}

    echo -e "\nRemoving intermediate sorted bam files ... "
    rm *.sort
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Create output folder
    mkdir -p $(dirname {output})

    # Make job specific scratch dir
    sampleID=$(echo $(basename $(dirname {input})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][kallistoIndex]}/${{sampleID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][kallistoIndex]}/${{sampleID}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][kallistoIndex]}/${{sampleID}}

    # Copy files
    echo -e "\nCopying and unzipping sample $sampleID assembly ... "
    cp {input} .

    # Rename files
    mv $(basename {input}) $(echo $sampleID|sed 's/$/.fa.gz/g')
    gunzip $(echo $sampleID|sed 's/$/.fa.gz/g')

    echo -e "\nCutting up assembly contigs >= 20kbp into 10kbp chunks ... "
    cut_up_fasta.py $sampleID.fa -c 10000 -o 0 --merge_last > contigs_10K.fa

    echo -e "\nCreating kallisto index ... "
    kallisto index contigs_10K.fa -i index.kaix

    mv index.kaix $(dirname {output})
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Create output folder
    mkdir -p {output}

    # Make job specific scratch dir
    focal=$(echo $(basename $(dirname {input.index})))
    mapping=$(echo $(basename $(dirname {input.R1})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][kallisto]}/${{focal}}_${{mapping}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][kallisto]}/${{focal}}_${{mapping}}

    # Move into tmp dir
    cd {config[path][scratch]}/{config[folder][kallisto]}/${{focal}}_${{mapping}}

    # Copy files
    echo -e "\nCopying assembly index {input.index} and reads {input.R1} {input.R2} to $(pwd) ... "
    cp {input.index} {input.R1} {input.R2} .

    # Run kallisto
    echo -e "\nRunning kallisto ... "
    kallisto quant --threads {config[cores][crossMap]} --plaintext -i index.kaix -o . $(basename {input.R1}) $(basename {input.R2})

    # Zip file
    echo -e "\nZipping abundance file ... "
    gzip abundance.tsv

    # Move mapping file out output folder
    mv abundance.tsv.gz {output}

    # Cleanup temp folder
    echo -e "\nRemoving temporary directory {config[path][scratch]}/{config[folder][kallisto]}/${{focal}}_${{mapping}} ... "
    cd -
    rm -r {config[path][scratch]}/{config[folder][kallisto]}/${{focal}}_${{mapping}}
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Create output folder
    mkdir -p $(dirname {output})

    # Make job specific scratch dir
    fsampleID=$(echo $(basename $(dirname {input.assembly})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][maxbin]}/${{fsampleID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][maxbin]}/${{fsampleID}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][maxbin]}/${{fsampleID}}

    # Copy files to tmp
    cp -r {input.assembly} {input.depth}/*.depth .

    echo -e "\nUnzipping assembly ... "
    gunzip $(basename {input.assembly})

    echo -e "\nGenerating list of depth files based on crossMapSeries rule output ... "
    find . -name "*.depth" > abund.list

    echo -e "\nRunning maxbin2 ... "
    run_MaxBin.pl -thread {config[cores][maxbin]} -contig contigs.fasta -out $(basename $(dirname {output})) -abund_list abund.list

    # Clean up un-needed files
    rm *.depth abund.list contigs.fasta

    # Move files into output dir
    mkdir -p $(basename {output})
    while read bin;do mv $bin $(basename {output});done< <(ls|grep fasta)
    mv * $(dirname {output})
    """

shell:
    """
    # Activate metawrap environment
    set +u;source activate {config[envs][metawrap]};set -u;

    # Create output folder
    mkdir -p {output}

    # Make job specific scratch dir
    fsampleID=$(echo $(basename $(dirname {input.concoct})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][refined]}/${{fsampleID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][refined]}/${{fsampleID}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][refined]}/${{fsampleID}}

    # Copy files to tmp
    echo "Copying bins from CONCOCT, metabat2, and maxbin2 to {config[path][scratch]} ... "
    cp -r {input.concoct} {input.metabat} {input.maxbin} .

    echo "Renaming bin folders to avoid errors with metaWRAP ... "
    mv $(basename {input.concoct}) $(echo $(basename {input.concoct})|sed 's/-bins//g')
    mv $(basename {input.metabat}) $(echo $(basename {input.metabat})|sed 's/-bins//g')
    mv $(basename {input.maxbin}) $(echo $(basename {input.maxbin})|sed 's/-bins//g')

    echo "Running metaWRAP bin refinement module ... "
    metaWRAP bin_refinement -o . \
        -A $(echo $(basename {input.concoct})|sed 's/-bins//g') \
        -B $(echo $(basename {input.metabat})|sed 's/-bins//g') \
        -C $(echo $(basename {input.maxbin})|sed 's/-bins//g') \
        -t {config[cores][refine]} \
        -m {config[params][refineMem]} \
        -c {config[params][refineComp]} \
        -x {config[params][refineCont]}

    rm -r $(echo $(basename {input.concoct})|sed 's/-bins//g') $(echo $(basename {input.metabat})|sed 's/-bins//g') $(echo $(basename {input.maxbin})|sed 's/-bins//g') work_files
    mv * {output}
    """

shell:
    """
    # Activate metagem env
    set +u;source activate {config[envs][metagem]};set -u;

    # Read CONCOCT bins
    echo "Generating concoct_bins.stats file containing bin ID, number of contigs, and length ... "
    cd {input}/{config[folder][concoct]}
    for folder in */;do 

        # Define sample name
        var=$(echo $folder|sed 's|/||g');
        for bin in $folder*concoct-bins/*.fa;do 

            # Define bin name
            name=$(echo $bin | sed "s|^.*/|$var.bin.|g" | sed 's/.fa//g');

            # Count contigs
            N=$(less $bin | grep -c ">");

            # Sum length
            L=$(less $bin |grep ">"|cut -d '-' -f4|sed 's/len=//g'|awk '{{sum+=$1}}END{{print sum}}')

            # Print values to terminal and write to stats file
            echo "Reading bin $bin ... Contigs: $N , Length: $L "
            echo $name $N $L >> concoct_bins.stats;
        done;
    done
    mv *.stats {input}/{config[folder][reassembled]}

    # Read MetaBAT2 bins
    echo "Generating metabat_bins.stats file containing bin ID, number of contigs, and length ... "
    cd {input}/{config[folder][metabat]}
    for folder in */;do 

        # Define sample name
        var=$(echo $folder | sed 's|/||');
        for bin in $folder*metabat-bins/*.fa;do 

            # Define bin name
            name=$(echo $bin|sed 's/.fa//g'|sed 's|^.*/||g'|sed "s/^/$var./g"); 

            # Count contigs
            N=$(less $bin | grep -c ">");

            # Sum length
            L=$(less $bin |grep ">"|cut -d '-' -f4|sed 's/len=//g'|awk '{{sum+=$1}}END{{print sum}}')

            # Print values to terminal and write to stats file
            echo "Reading bin $bin ... Contigs: $N , Length: $L "
            echo $name $N $L >> metabat_bins.stats;
        done;
    done
    mv *.stats {input}/{config[folder][reassembled]}

    # Read MaxBin2 bins
    echo "Generating maxbin_bins.stats file containing bin ID, number of contigs, and length ... "
    cd {input}/{config[folder][maxbin]}
    for folder in */;do
        for bin in $folder*maxbin-bins/*.fasta;do 

            # Define bin name
            name=$(echo $bin | sed 's/.fasta//g' | sed 's|^.*/||g');

            # Count contigs
            N=$(less $bin | grep -c ">");

            # Sum length
            L=$(less $bin |grep ">"|cut -d '-' -f4|sed 's/len=//g'|awk '{{sum+=$1}}END{{print sum}}')

            # Print values to terminal and write to stats file
            echo "Reading bin $bin ... Contigs: $N , Length: $L "
            echo $name $N $L >> maxbin_bins.stats;
        done;
    done
    mv *.stats {input}/{config[folder][reassembled]}

    # Read metaWRAP refined bins
    echo "Generating refined_bins.stats file containing bin ID, number of contigs, and length ... "
    cd {input}/{config[folder][refined]}
    for folder in */;do 

        # Define sample name 
        samp=$(echo $folder | sed 's|/||');
        for bin in $folder*metawrap_*_bins/*.fa;do 

            # Define bin name
            name=$(echo $bin | sed 's/.fa//g'|sed 's|^.*/||g'|sed "s/^/$samp./g");

            # Count contigs
            N=$(less $bin | grep -c ">");

            # Sum length
            L=$(less $bin |grep ">"|cut -d '-' -f4|sed 's/len_//g'|awk '{{sum+=$1}}END{{print sum}}')

            # Print values to terminal and write to stats file
            echo "Reading bin $bin ... Contigs: $N , Length: $L "
            echo $name $N $L >> refined_bins.stats;
        done;
    done

    # Compile CONCOCT, MetaBAT2, MaxBin2, and metaWRAP checkM files
    echo "Generating CheckM summary files across samples: concoct.checkm, metabat.checkm, maxbin.checkm, and refined.checkm ... "
    for folder in */;do 

        # Define sample name
        var=$(echo $folder|sed 's|/||g');

        # Write values to checkm files
        paste $folder*concoct.stats|tail -n +2 | sed "s/^/$var.bin./g" >> concoct.checkm
        paste $folder*metabat.stats|tail -n +2 | sed "s/^/$var./g" >> metabat.checkm
        paste $folder*maxbin.stats|tail -n +2 >> maxbin.checkm
        paste $folder*metawrap_*_bins.stats|tail -n +2|sed "s/^/$var./g" >> refined.checkm
    done 
    mv *.stats *.checkm {input}/{config[folder][reassembled]}

    # Read metaWRAP reassembled bins
    echo "Generating reassembled_bins.stats file containing bin ID, number of contigs, and length ... "
    cd {input}/{config[folder][reassembled]}
    for folder in */;do 

        # Define sample name 
        samp=$(echo $folder | sed 's|/||');
        for bin in $folder*reassembled_bins/*.fa;do 

            # Define bin name
            name=$(echo $bin | sed 's/.fa//g' | sed 's|^.*/||g' | sed "s/^/$samp./g");
            N=$(less $bin | grep -c ">");

            # Check if bins are original (megahit-assembled) or strict/permissive (metaspades-assembled)
            if [[ $name == *.strict ]] || [[ $name == *.permissive ]];then
                L=$(less $bin |grep ">"|cut -d '_' -f4|awk '{{sum+=$1}}END{{print sum}}')
            else
                L=$(less $bin |grep ">"|cut -d '-' -f4|sed 's/len_//g'|awk '{{sum+=$1}}END{{print sum}}')
            fi

            # Print values to terminal and write to stats file
            echo "Reading bin $bin ... Contigs: $N , Length: $L "
            echo $name $N $L >> reassembled_bins.stats;
        done;
    done
    echo "Done reading metawrap reassembled bins ... "

    # Read metaWRAP reassembled checkM file
    echo "Generating CheckM summary file reassembled.checkm across samples for reassembled bins ... "
    for folder in */;do 

        # Define sample name
        var=$(echo $folder|sed 's|/||g');

        # Write values to checkM file
        paste $folder*reassembled_bins.stats|tail -n +2|sed "s/^/$var./g";
    done >> reassembled.checkm
    echo "Done generating all statistics files for binning results ... running plotting script ... "

    # Move files and cd to stats folder
    mv *.stats *.checkm {config[path][root]}/{config[folder][stats]}
    cd {config[path][root]}/{config[folder][stats]}

    # Run Rscript
    Rscript {config[path][root]}/{config[folder][scripts]}/{config[scripts][binningVis]}

    # Delete redundant pdf file
    rm Rplots.pdf
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Make sure output folder exists
    mkdir -p {output}

    # Make job specific scratch dir
    sampleID=$(echo $(basename $(dirname {input})))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][classification]}/${{sampleID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][classification]}/${{sampleID}}

    # Move into scratch dir
    cd {config[path][scratch]}/{config[folder][classification]}/${{sampleID}}

    # Copy files
    echo -e "\nCopying files to tmp dir ... "
    cp -r {input} .

    # In case you GTDBTk is not properly configured you may need to export the GTDBTK_DATA_PATH variable,
    # Simply uncomment the following line and fill in the path to your GTDBTk database:
    # export GTDBTK_DATA_PATH=/path/to/the/gtdbtk/database/you/downloaded

    # Run GTDBTk
    gtdbtk classify_wf --genome_dir $(basename {input}) --out_dir GTDBTk -x fa --cpus {config[cores][gtdbtk]}

    mv GTDBTk/* {output}
    """

shell:
    """
    # Activate metagem environment
    set +u;source activate {config[envs][metagem]};set -u;

    # Make sure output folder exists
    mkdir -p $(dirname {output})

    # Make job specific scratch dir
    binID=$(echo $(basename {input})|sed 's/.faa//g')
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][GEMs]}/${{binID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][GEMs]}/${{binID}}

    # Move into tmp dir
    cd {config[path][scratch]}/{config[folder][GEMs]}/${{binID}}

    # Copy files
    cp {input.bin} {input.media} .

    echo "Begin carving GEM ... "
    carve -g {config[params][carveMedia]} \
        -v \
        --mediadb $(basename {input.media}) \
        --fbc2 \
        -o $(echo $(basename {input.bin}) | sed 's/.faa/.xml/g') $(basename {input.bin})

    echo "Done carving GEM. "
    [ -f *.xml ] && mv *.xml $(dirname {output})
    """

shell:
    """
    # Activate metagem env
    set +u;source activate {config[envs][metagem]};set -u

    # Make sure output folder exists
    mkdir -p $(dirname {output})

    # Make job specific scratch dir
    sampleID=$(echo $(basename {input}))
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][SMETANA]}/${{sampleID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][SMETANA]}/${{sampleID}}

    # Move to tmp dir
    cd {config[path][scratch]}/{config[folder][SMETANA]}/${{sampleID}}

    # Copy media db and GEMs
    cp {config[path][root]}/{config[folder][scripts]}/{config[scripts][carveme]} {input}/*.xml .

    # Run SMETANA        
    smetana -o $(basename {input}) --flavor fbc2 \
        --mediadb media_db.tsv -m {config[params][smetanaMedia]} \
        --detailed \
        --solver {config[params][smetanaSolver]} -v *.xml

    # Copy results to output folder
    cp *.tsv $(dirname {output})
    """

shell:
    """
    # Activate metagem env
    set +u;source activate {config[envs][metagem]};set -u

    # Make sure output folder exists
    mkdir -p {output}

    # Make job specific scratch dir
    gemID=$(echo $(basename {input})|sed 's/.xml//g')
    echo -e "\nCreating temporary directory {config[path][scratch]}/{config[folder][memote]}/${{gemID}} ... "
    mkdir -p {config[path][scratch]}/{config[folder][memote]}/${{gemID}}

    # Move to tmp dir
    cd {config[path][scratch]}/{config[folder][memote]}/${{gemID}}

    # Copy GEM to tmp
    cp {input} .

    # Uncomment the following line in case errors are raised about missing git module,
    # also ensure that module name matches that of your cluster
    # module load git

    # Run memote
    memote report snapshot --skip test_find_metabolites_produced_with_closed_bounds --skip test_find_metabolites_consumed_with_closed_bounds --skip test_find_metabolites_not_produced_with_open_bounds --skip test_find_metabolites_not_consumed_with_open_bounds --skip test_find_incorrect_thermodynamic_reversibility --filename $(echo $(basename {input})|sed 's/.xml/.html/') *.xml
    memote run --skip test_find_metabolites_produced_with_closed_bounds --skip test_find_metabolites_consumed_with_closed_bounds --skip test_find_metabolites_not_produced_with_open_bounds --skip test_find_metabolites_not_consumed_with_open_bounds --skip test_find_incorrect_thermodynamic_reversibility *.xml

    # Rename output file with sample ID
    mv result.json.gz $(echo $(basename {input})|sed 's/.xml/.json.gz/')

    # Move results to output folder
    mv *.gz *.html {output}
    """

shell:
    """
    set +u;source activate {config[envs][prokkaroary]};set -u
    mkdir -p $(dirname $(dirname {output}))
    mkdir -p $(dirname {output})

    cp {input} {config[path][scratch]}
    cd {config[path][scratch]}

    id=$(echo $(basename {input})|sed "s/.fa//g")
    prokka -locustag $id --cpus {config[cores][prokka]} --centre MAG --compliant -outdir prokka/$id -prefix $id $(basename {input})

    mv prokka/$id $(dirname {output})
    """

shell:
    """
    set +u;source activate {config[envs][prokkaroary]};set -u
    mkdir -p $(dirname {output})
    cd {config[path][scratch]}
    cp -r {input} .

    roary -s -p {config[cores][roary]} -i {config[params][roaryI]} -cd {config[params][roaryCD]} -f yes_al -e -v $(basename {input})/*.gff
    cd yes_al
    create_pan_genome_plots.R 
    cd ..
    mkdir -p {output}

    mv yes_al/* {output}
    """

shell:
    """
    mkdir -p $(dirname {output.gff})
    prodigal -i <(gunzip -c {input}) -o {output.gff} -a {output.faa} -d {output.fna} -p meta  &> {output.log}
    """