コード例 #1
0
    def run(self, infile, outfile, params):

        if not os.path.exists(params.reference_bam):
            raise OSError("reference bam file {} does not exist".format(
                params.reference_bam))

        tmpdir = P.get_temp_dir(clear=True)

        statement = (
            "mkdir {tmpdir}; "
            "samtools sort -n {infile} > {tmpdir}/comp.bam; "
            "samtools sort -n {params.reference_bam} > {tmpdir}/ref.bam; "
            "{params.path} bam-compare-alignments "
            "--output-filename-pattern={outfile}.daisy_bam_compare_alignments_%%s.tsv "
            "{params.options} "
            "--input-bam={tmpdir}/comp.bam "
            "--reference-bam={tmpdir}/ref.bam "
            ">& {outfile}; "
            "rm -rf {tmpdir}; ".format(**locals()))

        retval = P.run(statement)

        return retval
コード例 #2
0
    def run(self, infiles, outfile, params):

        tmpdir = P.get_temp_dir(clear=True)

        statements = ["mkdir {}".format(tmpdir)]

        if params.remove_fields:
            cleanup_statement = ("| {params.path} annotate "
                                 "-x {params.remove_fields} "
                                 "2> {outfile}_annotate.log ".format(
                                     **locals()))
        else:
            cleanup_statement = ""

        # the current pattern is properly overly specific and
        # substitutes ./. with 0/0
        if params.set_missing_genotype_to_reference:
            set_genotype = "| perl -p -e 's/\.\/\./0\/0/g'"
        else:
            set_genotype = ""

        with IOTools.open_file(outfile + ".filelist_blocks", "w") as blockf:

            for start in range(0, len(infiles), self.block_size):

                fn = outfile + ".filelist_{}".format(start)
                fn_vcf = os.path.join(tmpdir, "block_{}.vcf.gz".format(start))
                with IOTools.open_file(fn, "w") as outf:
                    end = start + self.block_size
                    outf.write("\n".join(infiles[start:end]) + "\n")

                statements.append("{params.path} merge "
                                  "{params.options} "
                                  "-O v "
                                  "--file-list {outfile}.filelist_{start} "
                                  "2> {outfile}_merge_{start}.log "
                                  "{cleanup_statement} "
                                  "{set_genotype} "
                                  "| bgzip "
                                  "> {fn_vcf}; "
                                  "tabix -p vcf {fn_vcf}".format(**locals()))

                blockf.write(fn_vcf + "\n")

        if params.restrict_to_all:
            filter_statement = ("| {params.path} filter "
                                "--include \"FORMAT/GT != '.'\" "
                                "-O v "
                                "2> {outfile}_filter.log ".format(**locals()))
        else:
            filter_statement = ""

        statements.append("{params.path} merge "
                          "{params.options} "
                          "-O v "
                          "--file-list {outfile}.filelist_blocks "
                          "2> {outfile}_merge.log "
                          "{filter_statement} "
                          "| bgzip "
                          "> {outfile}; "
                          "tabix -p vcf {outfile} ".format(**locals()))

        statements.append("rm -rf {}".format(tmpdir))

        statement = "; ".join(statements)

        retvals = P.run(statement, **params._asdict())

        return retvals