klassify 0.1.6

Classify chimeric reads based on unique kmer contents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use clap::Parser;
use libc::{SIGPIPE, SIG_DFL};

use klassify::breakpoint;
use klassify::build;
use klassify::classify;
use klassify::cluster_pairs;
use klassify::extract;
use klassify::extract_bam;
use klassify::pipeline;
use klassify::regions;
use klassify::tools::info;
use klassify::tools::sort_bam;

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about=None)]
struct Args {
    #[clap(subcommand)]
    subcommand: SubCommand,
}

#[derive(Parser, Debug)]
enum SubCommand {
    #[clap(about = "Detect breakpoints")]
    Breakpoint(breakpoint::BreakpointArgs),
    #[clap(about = "Build reference kmer table")]
    Build(build::BuildArgs),
    #[clap(about = "Classify reads")]
    Classify(classify::ClassifyArgs),
    #[clap(about = "Cluster paired cross-over regions")]
    ClusterPairs(cluster_pairs::ClusterPairsArgs),
    #[clap(about = "Print details about the kmer table")]
    Info(info::InfoArgs),
    #[clap(about = "Extract reads")]
    Extract(extract::ExtractArgs),
    #[clap(about = "Extract reads from BAM")]
    ExtractBam(extract_bam::ExtractBamArgs),
    #[clap(about = "Run simple pipeline from start to end")]
    Pipeline(pipeline::PipelineArgs),
    #[clap(about = "Prepare BAM files and generate depths for each bin")]
    Regions(regions::RegionsArgs),
    #[clap(about = "Sort BAM file by divergence")]
    SortBam(sort_bam::SortBamArgs),
}

fn main() {
    env_logger::init_from_env(
        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
    );

    // RUST annoyingly panicked when piping results to `head` (which isn't technically an error),
    // so we need to disable this.
    unsafe {
        libc::signal(SIGPIPE, SIG_DFL);
    }

    let args = Args::parse();
    match args.subcommand {
        SubCommand::Build(build) => {
            build::build(&build.fasta_files, &build.output_file, build.kmer_size);
        }
        SubCommand::Breakpoint(breakpoint) => {
            breakpoint::breakpoint(breakpoint);
        }
        SubCommand::Classify(classify) => {
            classify::classify(
                &classify.bincode_file,
                &classify.reads_file,
                &classify.output_dir,
                classify.prefix_length,
            );
        }
        SubCommand::ClusterPairs(cluster_pairs) => {
            cluster_pairs::cluster_pairs(cluster_pairs);
        }
        SubCommand::Info(info) => {
            info::info(&info.bincode_file);
        }
        SubCommand::Extract(extract) => {
            extract::extract(
                &extract.reads_tsv,
                &extract.fasta_files,
                &extract.output_file,
            );
        }
        SubCommand::ExtractBam(extract_bam) => {
            extract_bam::extract_bam(
                &extract_bam.regions_file,
                &extract_bam.bam_file,
                extract_bam.flank_size,
            );
        }
        SubCommand::Pipeline(pipeline) => {
            _ = pipeline::pipeline(pipeline);
        }
        SubCommand::Regions(regions) => {
            regions::regions(
                &regions.bam_files,
                !regions.no_chr_only,
                regions.min_support,
                regions.max_support,
            );
        }
        SubCommand::SortBam(sort_bam) => {
            sort_bam::sort_bam(
                &sort_bam.input,
                &sort_bam.output,
                sort_bam.max_de,
                sort_bam.min_mapq,
            );
        }
    }
}