rasusa 5.0.1

Randomly subsample reads or alignments
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

use std::fs::File;
use std::io::{self, Write};

use anyhow::{Context, Result};
use log::info;
use rand::prelude::*;
use rand::random;

use noodles::sam::Header;

use crate::format::infer_format_from_path;
use crate::threading::build_alignment_writer;

use super::args::Alignment;
use super::header::program_entry;

// re-exported so `stream.rs`/`fetch.rs`/`mod.rs` can keep referring to it as `super::io::AlignmentWriter`
pub(super) use crate::threading::AlignmentWriter;

impl Alignment {
    pub(super) fn setup_resources(
        &self,
        input_header: &Header,
    ) -> Result<(rand_pcg::Pcg64, AlignmentWriter)> {
        // set up random number generator
        let rng = match self.seed {
            Some(s) => rand_pcg::Pcg64::seed_from_u64(s),
            None => {
                let seed = random();
                info!("Using seed: {seed}");
                rand_pcg::Pcg64::seed_from_u64(seed)
            }
        };

        let mut header = input_header.clone();

        // add rasusa program command line to header
        let (pg_id, pg_map) = program_entry(&header);

        // set up the header and writer
        header.programs_mut().as_mut().insert(pg_id.into(), pg_map);

        let input_fmt = match infer_format_from_path(&self.aln) {
            Some(fmt) => fmt,
            None => {
                return Err(anyhow::anyhow!(
                    "Output file format not recognized. Please use .sam, .bam, or .cram extensions"
                ));
            }
        };

        let output_fmt = match &self.output_format {
            Some(fmt) => *fmt,
            None => match &self.output {
                None => input_fmt,
                Some(path) => match infer_format_from_path(path) {
                    Some(fmt) => fmt,
                    None => {
                        return Err(anyhow::anyhow!(
                            "Output file format not recognized. Please use .sam, .bam, or .cram extensions"
                        ));
                    }
                },
            },
        };

        // use Box<dyn Write + Send> to make File and Stdout compatible, and to allow wrapping in
        // a multithreaded BGZF encoder when `--threads` > 1.
        let sink: Box<dyn Write + Send> = match &self.output {
            Some(path) => {
                let path = path.as_path();
                info!("Writing subsampled alignment to: {:?}", path);
                let file = File::create(path).context("Failed to create output alignment file")?;
                Box::new(file)
            }
            None => {
                info!("Writing subsampled alignment to stdout");
                // `Stdout` (rather than a `StdoutLock`) so the sink is `Send`: it can be wrapped
                // in a multithreaded BGZF encoder, whose background writer thread needs to own
                // it. `Stdout::write` still locks internally on every call.
                Box::new(io::stdout())
            }
        };

        let mut writer = build_alignment_writer(sink, output_fmt, self.threads)?;

        writer.write_header(&header)?;

        Ok((rng, writer))
    }
}