Skip to main content

rsomics_fastq_qc/
lib.rs

1#![forbid(unsafe_code)]
2#![allow(
3    clippy::missing_errors_doc,
4    clippy::missing_panics_doc,
5    clippy::must_use_candidate
6)]
7
8mod html;
9mod modules;
10mod report;
11
12use std::path::Path;
13
14use rsomics_common::{Context, Result, RsomicsError};
15use rsomics_seqio::Format;
16
17use modules::{
18    AdapterContent, BasicStats, DuplicationLevels, OverrepresentedSeqs, PerBaseContent,
19    PerBaseNContent, PerBaseQuality, PerSeqGc, PerSeqQuality, PerTileQuality, QcModule,
20    SeqLengthDistribution,
21};
22
23pub use report::{BatchReport, FileReport, ModuleResult, ReportOptions, write_reports};
24
25pub struct Analysis {
26    basic: BasicStats,
27    base_quality: PerBaseQuality,
28    tile_quality: PerTileQuality,
29    sequence_quality: PerSeqQuality,
30    base_content: PerBaseContent,
31    sequence_gc: PerSeqGc,
32    n_content: PerBaseNContent,
33    length: SeqLengthDistribution,
34    duplication: DuplicationLevels,
35    overrepresented: OverrepresentedSeqs,
36    adapter: AdapterContent,
37}
38
39impl Analysis {
40    fn new(filename: &str) -> Self {
41        Self {
42            basic: BasicStats::new(filename),
43            base_quality: PerBaseQuality::new(),
44            tile_quality: PerTileQuality::new(),
45            sequence_quality: PerSeqQuality::new(),
46            base_content: PerBaseContent::new(),
47            sequence_gc: PerSeqGc::new(),
48            n_content: PerBaseNContent::new(),
49            length: SeqLengthDistribution::new(),
50            duplication: DuplicationLevels::new(),
51            overrepresented: OverrepresentedSeqs::new(),
52            adapter: AdapterContent::new(),
53        }
54    }
55
56    fn process(&mut self, record: &modules::Record<'_>) {
57        self.basic.process(record);
58        self.base_quality.process(record);
59        self.tile_quality.process(record);
60        self.sequence_quality.process(record);
61        self.base_content.process(record);
62        self.sequence_gc.process(record);
63        self.n_content.process(record);
64        self.length.process(record);
65        self.duplication.process(record);
66        self.adapter.process(record);
67    }
68
69    fn finalize(&mut self) {
70        self.basic.finalize();
71        self.base_quality.finalize();
72        self.tile_quality.finalize();
73        self.sequence_quality.finalize();
74        self.base_content.finalize();
75        self.sequence_gc.finalize();
76        self.n_content.finalize();
77        self.length.finalize();
78        self.duplication.finalize();
79        self.overrepresented
80            .attach(self.duplication.shared_counts());
81        self.overrepresented.finalize();
82        self.adapter.finalize();
83    }
84}
85
86pub fn analyze(path: &Path) -> Result<Analysis> {
87    let mut reader = rsomics_seqio::open_path(path)?;
88    if reader.format() != Format::Fastq {
89        return Err(RsomicsError::InvalidInput(format!(
90            "{} is not a FASTQ stream",
91            path.display()
92        )));
93    }
94
95    let filename = path.file_name().map_or_else(
96        || path.display().to_string(),
97        |name| name.to_string_lossy().into_owned(),
98    );
99    let mut analysis = Analysis::new(&filename);
100    let mut records = 0_u64;
101    while let Some(record) = reader
102        .read_record()
103        .rs_with_context(|| format!("parsing {}", path.display()))?
104    {
105        let quality = record.qual.ok_or_else(|| {
106            RsomicsError::InvalidInput(format!("{} is not a FASTQ stream", path.display()))
107        })?;
108        analysis.process(&modules::Record {
109            id: record.id,
110            seq: record.seq,
111            qual: quality,
112        });
113        records += 1;
114    }
115    if records == 0 {
116        return Err(RsomicsError::InvalidInput(format!(
117            "{} contains no FASTQ records",
118            path.display()
119        )));
120    }
121    analysis.finalize();
122    Ok(analysis)
123}