Skip to main content

rsomics_call/
stream.rs

1use std::collections::HashSet;
2use std::fs::File;
3use std::io::{self, BufWriter, Read, Write};
4use std::path::Path;
5
6use noodles::{
7    bcf, bgzf,
8    core::{Position, Region},
9    vcf,
10    vcf::variant::{Record as _, io::Write as _},
11};
12use noodles_util::variant;
13
14use crate::{CallError, CalledSite, CalledVcfSchema, LikelihoodSite, LikelihoodVcfSchema, Result};
15
16#[derive(Clone, Copy, Debug, PartialEq, Eq)]
17pub enum VariantOutputFormat {
18    Vcf,
19    VcfBgzf,
20    BcfRaw,
21    BcfBgzf,
22}
23
24pub struct LikelihoodVariantReader<R>
25where
26    R: Read,
27{
28    inner: variant::io::Reader<R>,
29    projection: LikelihoodProjection,
30    record: variant::Record,
31    record_number: u64,
32    started: bool,
33}
34
35impl<R> LikelihoodVariantReader<R>
36where
37    R: Read,
38{
39    pub fn new(reader: R) -> Result<Self> {
40        let mut inner = variant::io::Reader::new(reader).map_err(input_error)?;
41        let header = inner.read_header().map_err(input_error)?;
42        Ok(Self {
43            inner,
44            projection: LikelihoodProjection::new(header)?,
45            record: variant::Record::default(),
46            record_number: 0,
47            started: false,
48        })
49    }
50
51    pub fn schema(&self) -> &LikelihoodVcfSchema {
52        self.projection.schema()
53    }
54
55    pub fn record_number(&self) -> u64 {
56        self.record_number
57    }
58
59    pub fn select_samples(
60        mut self,
61        samples: impl IntoIterator<Item = impl AsRef<str>>,
62    ) -> Result<Self> {
63        self.require_unread()?;
64        self.projection.select_samples(samples)?;
65        Ok(self)
66    }
67
68    pub fn exclude_samples(
69        mut self,
70        samples: impl IntoIterator<Item = impl AsRef<str>>,
71    ) -> Result<Self> {
72        self.require_unread()?;
73        self.projection.exclude_samples(samples)?;
74        Ok(self)
75    }
76
77    pub fn with_prior_frequencies(
78        mut self,
79        total_alleles_tag: impl Into<String>,
80        alternate_counts_tag: impl Into<String>,
81    ) -> Result<Self> {
82        self.require_unread()?;
83        self.projection
84            .set_prior_frequency_tags(total_alleles_tag, alternate_counts_tag)?;
85        Ok(self)
86    }
87
88    pub fn read_site(&mut self) -> Result<Option<LikelihoodSite>> {
89        self.started = true;
90        let record_number = self.record_number + 1;
91        let size = self
92            .inner
93            .read_record(&mut self.record)
94            .map_err(|error| record_error(record_number, error))?;
95        if size == 0 {
96            return Ok(None);
97        }
98        self.record_number = record_number;
99        let record = vcf::variant::RecordBuf::try_from_variant_record(
100            self.projection.input_header(),
101            &self.record,
102        )
103        .map_err(|error| record_error(record_number, error))?;
104        self.projection
105            .decode(&record)
106            .map_err(|error| CallError::LikelihoodVariantRecord {
107                record: record_number,
108                message: error.to_string(),
109            })
110            .map(Some)
111    }
112
113    fn require_unread(&self) -> Result<()> {
114        if self.started {
115            return Err(CallError::LateLikelihoodReaderConfiguration);
116        }
117        Ok(())
118    }
119}
120
121pub struct IndexedLikelihoodVariantReader {
122    inner: variant::io::indexed_reader::IndexedReader<bgzf::io::Reader<File>>,
123    projection: LikelihoodProjection,
124}
125
126impl IndexedLikelihoodVariantReader {
127    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
128        let path = path.as_ref();
129        let mut inner = variant::io::indexed_reader::Builder::default()
130            .build_from_path(path)
131            .map_err(|error| path_input_error(path, error))?;
132        let header = inner
133            .read_header()
134            .map_err(|error| path_input_error(path, error))?;
135        Ok(Self {
136            inner,
137            projection: LikelihoodProjection::new(header)?,
138        })
139    }
140
141    pub fn schema(&self) -> &LikelihoodVcfSchema {
142        self.projection.schema()
143    }
144
145    pub fn select_samples(
146        mut self,
147        samples: impl IntoIterator<Item = impl AsRef<str>>,
148    ) -> Result<Self> {
149        self.projection.select_samples(samples)?;
150        Ok(self)
151    }
152
153    pub fn exclude_samples(
154        mut self,
155        samples: impl IntoIterator<Item = impl AsRef<str>>,
156    ) -> Result<Self> {
157        self.projection.exclude_samples(samples)?;
158        Ok(self)
159    }
160
161    pub fn with_prior_frequencies(
162        mut self,
163        total_alleles_tag: impl Into<String>,
164        alternate_counts_tag: impl Into<String>,
165    ) -> Result<Self> {
166        self.projection
167            .set_prior_frequency_tags(total_alleles_tag, alternate_counts_tag)?;
168        Ok(self)
169    }
170
171    pub(crate) fn normalize_regions(
172        &self,
173        regions: impl IntoIterator<Item = Region>,
174    ) -> Result<PreparedVariantRegions> {
175        normalize_variant_regions(self.projection.input_header(), regions)
176    }
177
178    pub(crate) fn normalize_region_file(
179        &self,
180        regions: impl IntoIterator<Item = Region>,
181    ) -> Result<PreparedVariantRegions> {
182        normalize_variant_region_file(self.projection.input_header(), regions)
183    }
184
185    pub(crate) fn visit_normalized_regions(
186        mut self,
187        regions: PreparedVariantRegions,
188        mut visit: impl FnMut(u64, LikelihoodSite) -> Result<()>,
189    ) -> Result<()> {
190        let header = self.projection.input_header();
191        let mut record_number = 0;
192
193        for (region_index, region) in regions.values.iter().enumerate() {
194            let records = self
195                .inner
196                .query(header, &region.query)
197                .map_err(|error| query_error(&region.query, error))?;
198            for result in records {
199                record_number += 1;
200                let record = result.map_err(|error| record_error(record_number, error))?;
201                let record =
202                    vcf::variant::RecordBuf::try_from_variant_record(header, record.as_ref())
203                        .map_err(|error| record_error(record_number, error))?;
204                let start = record.variant_start().ok_or_else(|| {
205                    record_error(
206                        record_number,
207                        io::Error::new(io::ErrorKind::InvalidData, "missing variant position"),
208                    )
209                })?;
210                let end = record
211                    .variant_end(header)
212                    .map_err(|error| record_error(record_number, error))?;
213                if regions.deduplicate
214                    && regions.values[..region_index]
215                        .iter()
216                        .any(|previous| previous.overlaps(region.reference_id, start, end))
217                {
218                    continue;
219                }
220                let site = self.projection.decode(&record).map_err(|error| {
221                    CallError::LikelihoodVariantRecord {
222                        record: record_number,
223                        message: error.to_string(),
224                    }
225                })?;
226                visit(record_number, site)?;
227            }
228        }
229        Ok(())
230    }
231}
232
233pub(crate) struct VariantRegion {
234    query: Region,
235    reference_id: usize,
236    start: Position,
237    end: Position,
238}
239
240pub(crate) struct PreparedVariantRegions {
241    values: Vec<VariantRegion>,
242    deduplicate: bool,
243}
244
245impl VariantRegion {
246    fn overlaps(&self, reference_id: usize, start: Position, end: Position) -> bool {
247        self.reference_id == reference_id && start <= self.end && end >= self.start
248    }
249}
250
251fn normalize_variant_regions(
252    header: &vcf::Header,
253    regions: impl IntoIterator<Item = Region>,
254) -> Result<PreparedVariantRegions> {
255    let mut values = resolve_variant_regions(header, regions)?;
256    values.sort_unstable_by_key(|region| (region.reference_id, region.start, region.end));
257
258    let mut merged: Vec<VariantRegion> = Vec::with_capacity(values.len());
259    for region in values {
260        if let Some(previous) = merged.last_mut()
261            && previous.reference_id == region.reference_id
262            && region.start <= previous.end.checked_add(1).unwrap_or(Position::MAX)
263        {
264            previous.end = previous.end.max(region.end);
265            previous.query = Region::new(
266                previous.query.name().to_vec(),
267                previous.start..=previous.end,
268            );
269        } else {
270            merged.push(region);
271        }
272    }
273    Ok(PreparedVariantRegions {
274        values: merged,
275        deduplicate: true,
276    })
277}
278
279fn normalize_variant_region_file(
280    header: &vcf::Header,
281    regions: impl IntoIterator<Item = Region>,
282) -> Result<PreparedVariantRegions> {
283    let mut values = resolve_variant_regions(header, regions)?;
284    let mut ranks = vec![usize::MAX; header.contigs().len()];
285    let mut next_rank = 0;
286    for region in &values {
287        if ranks[region.reference_id] == usize::MAX {
288            ranks[region.reference_id] = next_rank;
289            next_rank += 1;
290        }
291    }
292    values.sort_by_key(|region| (ranks[region.reference_id], region.start, region.end));
293    Ok(PreparedVariantRegions {
294        values,
295        deduplicate: true,
296    })
297}
298
299fn resolve_variant_regions(
300    header: &vcf::Header,
301    regions: impl IntoIterator<Item = Region>,
302) -> Result<Vec<VariantRegion>> {
303    let mut values = Vec::new();
304    for region in regions {
305        let name =
306            std::str::from_utf8(region.name().as_ref()).map_err(|_| CallError::InvalidRegion {
307                region: region.to_string(),
308                message: "reference sequence name is not UTF-8".to_owned(),
309            })?;
310        let (reference_id, _, contig) =
311            header
312                .contigs()
313                .get_full(name)
314                .ok_or_else(|| CallError::InvalidRegion {
315                    region: region.to_string(),
316                    message: "reference sequence is absent from the variant header".to_owned(),
317                })?;
318        let start = region.interval().start().unwrap_or(Position::MIN);
319        let end = match contig.length().and_then(Position::new) {
320            Some(length) if start > length => {
321                return Err(CallError::InvalidRegion {
322                    region: region.to_string(),
323                    message: "interval is outside the reference sequence".to_owned(),
324                });
325            }
326            Some(length) => region.interval().end().unwrap_or(length).min(length),
327            None => region.interval().end().unwrap_or(Position::MAX),
328        };
329        values.push(VariantRegion {
330            query: Region::new(name, start..=end),
331            reference_id,
332            start,
333            end,
334        });
335    }
336    if values.is_empty() {
337        return Err(CallError::MissingRegions);
338    }
339    Ok(values)
340}
341
342pub(crate) struct LikelihoodProjection {
343    input_schema: LikelihoodVcfSchema,
344    schema: LikelihoodVcfSchema,
345    sample_indices: Box<[usize]>,
346}
347
348impl LikelihoodProjection {
349    pub(crate) fn new(header: vcf::Header) -> Result<Self> {
350        let schema = LikelihoodVcfSchema::from_header(header)?;
351        let sample_indices = (0..schema.header().sample_names().len()).collect();
352        Ok(Self {
353            input_schema: schema.clone(),
354            schema,
355            sample_indices,
356        })
357    }
358
359    pub(crate) fn schema(&self) -> &LikelihoodVcfSchema {
360        &self.schema
361    }
362
363    pub(crate) fn input_header(&self) -> &vcf::Header {
364        self.input_schema.header()
365    }
366
367    pub(crate) fn select_samples(
368        &mut self,
369        samples: impl IntoIterator<Item = impl AsRef<str>>,
370    ) -> Result<()> {
371        let mut seen = HashSet::new();
372        let mut indices = Vec::new();
373        for sample in samples {
374            let sample = sample.as_ref();
375            if !seen.insert(sample.to_owned()) {
376                return Err(CallError::DuplicateSampleSelection(sample.to_owned()));
377            }
378            let index = self
379                .input_schema
380                .header()
381                .sample_names()
382                .get_index_of(sample)
383                .ok_or_else(|| CallError::MissingSelectedSample(sample.to_owned()))?;
384            indices.push(index);
385        }
386        self.set_sample_indices(indices)
387    }
388
389    pub(crate) fn exclude_samples(
390        &mut self,
391        samples: impl IntoIterator<Item = impl AsRef<str>>,
392    ) -> Result<()> {
393        let mut excluded = HashSet::new();
394        for sample in samples {
395            let sample = sample.as_ref();
396            if !excluded.insert(sample.to_owned()) {
397                return Err(CallError::DuplicateSampleSelection(sample.to_owned()));
398            }
399            if !self.input_schema.header().sample_names().contains(sample) {
400                return Err(CallError::MissingSelectedSample(sample.to_owned()));
401            }
402        }
403        let indices = self
404            .input_schema
405            .header()
406            .sample_names()
407            .iter()
408            .enumerate()
409            .filter_map(|(index, sample)| (!excluded.contains(sample)).then_some(index))
410            .collect();
411        self.set_sample_indices(indices)
412    }
413
414    pub(crate) fn decode(&self, record: &vcf::variant::RecordBuf) -> Result<LikelihoodSite> {
415        self.input_schema
416            .decode_selected_likelihood(record, &self.sample_indices)
417    }
418
419    pub(crate) fn set_prior_frequency_tags(
420        &mut self,
421        total: impl Into<String>,
422        alternates: impl Into<String>,
423    ) -> Result<()> {
424        let total = total.into();
425        let alternates = alternates.into();
426        self.input_schema
427            .set_prior_frequency_tags(total.clone(), alternates.clone())?;
428        self.schema.set_prior_frequency_tags(total, alternates)
429    }
430
431    fn set_sample_indices(&mut self, indices: Vec<usize>) -> Result<()> {
432        if indices.is_empty() {
433            return Err(CallError::InvalidSampleCount);
434        }
435        let mut header = self.input_schema.header().clone();
436        header.sample_names_mut().clear();
437        for &index in &indices {
438            header
439                .sample_names_mut()
440                .insert(self.input_schema.header().sample_names()[index].clone());
441        }
442        let prior_frequency_tags = self
443            .schema
444            .prior_frequency_tags()
445            .map(|(total, alternates)| (total.to_owned(), alternates.to_owned()));
446        self.schema = LikelihoodVcfSchema::from_header(header)?;
447        if let Some((total, alternates)) = prior_frequency_tags {
448            self.schema.set_prior_frequency_tags(total, alternates)?;
449        }
450        self.sample_indices = indices.into_boxed_slice();
451        Ok(())
452    }
453}
454
455pub struct LikelihoodVariantWriter<W>
456where
457    W: Write,
458{
459    inner: VariantWriter<W>,
460    schema: LikelihoodVcfSchema,
461}
462
463impl<W> LikelihoodVariantWriter<W>
464where
465    W: Write,
466{
467    pub fn new(
468        writer: W,
469        schema: LikelihoodVcfSchema,
470        format: VariantOutputFormat,
471    ) -> Result<Self> {
472        let mut inner = VariantWriter::new(writer, format);
473        inner.write_header(schema.header())?;
474        Ok(Self { inner, schema })
475    }
476
477    pub fn schema(&self) -> &LikelihoodVcfSchema {
478        &self.schema
479    }
480
481    pub fn write_site(&mut self, site: &LikelihoodSite) -> Result<()> {
482        let record = self.schema.encode_likelihood(site)?;
483        self.inner.write_record(self.schema.header(), &record)
484    }
485
486    pub fn finish(self) -> Result<W> {
487        self.inner.finish()
488    }
489}
490
491pub struct CalledVariantWriter<W>
492where
493    W: Write,
494{
495    inner: VariantWriter<W>,
496    schema: CalledVcfSchema,
497}
498
499impl<W> CalledVariantWriter<W>
500where
501    W: Write,
502{
503    pub fn new(writer: W, schema: CalledVcfSchema, format: VariantOutputFormat) -> Result<Self> {
504        let mut inner = VariantWriter::new(writer, format);
505        inner.write_header(schema.header())?;
506        Ok(Self { inner, schema })
507    }
508
509    pub fn schema(&self) -> &CalledVcfSchema {
510        &self.schema
511    }
512
513    pub fn write_site(&mut self, site: &CalledSite) -> Result<()> {
514        let record = self.schema.encode_call(site)?;
515        self.inner.write_record(self.schema.header(), &record)
516    }
517
518    pub fn finish(self) -> Result<W> {
519        self.inner.finish()
520    }
521}
522
523enum VariantWriter<W>
524where
525    W: Write,
526{
527    Vcf(vcf::io::Writer<BufWriter<W>>),
528    VcfBgzf(vcf::io::Writer<bgzf::io::Writer<W>>),
529    BcfRaw(bcf::io::Writer<BufWriter<W>>),
530    BcfBgzf(bcf::io::Writer<bgzf::io::Writer<W>>),
531}
532
533impl<W> VariantWriter<W>
534where
535    W: Write,
536{
537    fn new(writer: W, format: VariantOutputFormat) -> Self {
538        match format {
539            VariantOutputFormat::Vcf => Self::Vcf(vcf::io::Writer::new(BufWriter::new(writer))),
540            VariantOutputFormat::VcfBgzf => {
541                Self::VcfBgzf(vcf::io::Writer::new(bgzf::io::Writer::new(writer)))
542            }
543            VariantOutputFormat::BcfRaw => {
544                Self::BcfRaw(bcf::io::Writer::from(BufWriter::new(writer)))
545            }
546            VariantOutputFormat::BcfBgzf => Self::BcfBgzf(bcf::io::Writer::new(writer)),
547        }
548    }
549
550    fn write_header(&mut self, header: &vcf::Header) -> Result<()> {
551        match self {
552            Self::Vcf(writer) => writer.write_header(header),
553            Self::VcfBgzf(writer) => writer.write_header(header),
554            Self::BcfRaw(writer) => writer.write_header(header),
555            Self::BcfBgzf(writer) => writer.write_header(header),
556        }
557        .map_err(output_error)
558    }
559
560    fn write_record(
561        &mut self,
562        header: &vcf::Header,
563        record: &dyn vcf::variant::Record,
564    ) -> Result<()> {
565        match self {
566            Self::Vcf(writer) => writer.write_variant_record(header, record),
567            Self::VcfBgzf(writer) => writer.write_variant_record(header, record),
568            Self::BcfRaw(writer) => writer.write_variant_record(header, record),
569            Self::BcfBgzf(writer) => writer.write_variant_record(header, record),
570        }
571        .map_err(output_error)
572    }
573
574    fn finish(self) -> Result<W> {
575        match self {
576            Self::Vcf(writer) => finish_buffer(writer.into_inner()),
577            Self::VcfBgzf(writer) => writer.into_inner().finish().map_err(output_error),
578            Self::BcfRaw(writer) => finish_buffer(writer.into_inner()),
579            Self::BcfBgzf(writer) => writer.into_inner().finish().map_err(output_error),
580        }
581    }
582}
583
584fn finish_buffer<W>(writer: BufWriter<W>) -> Result<W>
585where
586    W: Write,
587{
588    writer
589        .into_inner()
590        .map_err(|error| output_error(error.into_error()))
591}
592
593fn input_error(error: io::Error) -> CallError {
594    CallError::LikelihoodVariantInput(error.to_string())
595}
596
597fn path_input_error(path: &Path, error: io::Error) -> CallError {
598    CallError::LikelihoodVariantInput(format!("{}: {error}", path.display()))
599}
600
601fn query_error(region: &Region, error: io::Error) -> CallError {
602    CallError::LikelihoodVariantInput(format!("querying region {region}: {error}"))
603}
604
605fn record_error(record: u64, error: io::Error) -> CallError {
606    CallError::LikelihoodVariantRecord {
607        record,
608        message: error.to_string(),
609    }
610}
611
612fn output_error(error: io::Error) -> CallError {
613    CallError::VariantOutput(error.to_string())
614}
615
616#[cfg(test)]
617mod tests;