bamslice 0.2.1

Extract byte ranges from BAM files and convert to interleaved FASTQ format for parallel processing
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

use anyhow::{Context, Result};
use clap::Parser;
use log::info;

/// Extract specific BGZF blocks from BAM files and convert to interleaved FASTQ
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Input BAM file
    #[arg(short, long)]
    input: String,

    /// Starting byte offset (will find next BGZF block at or after this offset)
    #[arg(short = 's', long)]
    start_offset: u64,

    /// Ending byte offset (will process until reaching a block at or after this offset)
    #[arg(short = 'e', long)]
    end_offset: u64,

    /// Output file (default: stdout)
    #[arg(short, long)]
    output: Option<String>,

    /// Output format: fastq or bam
    #[arg(short, long, default_value = "fastq")]
    format: String,

    /// Log level (off, error, warn, info, debug, trace)
    #[arg(short = 'l', long, default_value = "info")]
    log_level: String,
}

fn main() -> Result<()> {
    let args = Args::parse();

    // Initialize logger with specified level (can be overridden by RUST_LOG env var)
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or(&args.log_level))
        .init();

    // Validate arguments
    if args.start_offset >= args.end_offset {
        anyhow::bail!(
            "start_offset ({}) must be less than end_offset ({})",
            args.start_offset,
            args.end_offset
        );
    }

    // Uses Box<dyn Write> to handle both File and Stdout via dynamic dispatch.
    // This simplifies the code compared to generics, at the cost of slight runtime overhead.
    let mut writer: Box<dyn std::io::Write> = if let Some(output_path) = &args.output {
        let file = std::fs::File::create(output_path)
            .with_context(|| format!("Failed to create output file {output_path}"))?;
        Box::new(std::io::BufWriter::new(file))
    } else {
        let stdout = std::io::stdout();
        Box::new(std::io::BufWriter::new(stdout.lock()))
    };

    let format = match args.format.as_str() {
        "fastq" => bamslice::OutputFormat::Fastq,
        "bam" => bamslice::OutputFormat::Bam,
        other => anyhow::bail!("Unknown format '{other}'. Expected 'fastq' or 'bam'."),
    };

    let processed_reads = bamslice::process_blocks(
        &args.input,
        args.start_offset,
        args.end_offset,
        &mut writer,
        format,
    )?;

    info!("Total reads extracted: {processed_reads}");
    Ok(())
}