rsomics-call 0.1.3

Typed alignment likelihood and small-variant calling workflow
Documentation
use crate::{CallError, CalledSite, GvcfSite, Result};

pub struct GvcfBlocker {
    thresholds: Box<[u32]>,
    block: Option<Block>,
    previous: Option<(usize, u64)>,
}

struct Block {
    site: CalledSite,
    end: u64,
    minimum_depth: u32,
    range: usize,
}

impl GvcfBlocker {
    pub fn new(thresholds: impl Into<Box<[u32]>>) -> Result<Self> {
        let thresholds = thresholds.into();
        if thresholds.is_empty() || thresholds.windows(2).any(|pair| pair[0] >= pair[1]) {
            return Err(CallError::InvalidGvcfThresholds);
        }
        Ok(Self {
            thresholds,
            block: None,
            previous: None,
        })
    }

    pub fn thresholds(&self) -> &[u32] {
        &self.thresholds
    }

    pub fn push(
        &mut self,
        mut site: CalledSite,
        mut emit: impl FnMut(CalledSite) -> Result<()>,
    ) -> Result<()> {
        let coordinate = (site.reference_sequence_id(), site.position());
        if self.previous.is_some_and(|previous| coordinate < previous) {
            return Err(CallError::InvalidGvcfOrder);
        }
        self.previous = Some(coordinate);

        let minimum_depth = site
            .samples()
            .iter()
            .map(|sample| sample.evidence().depth())
            .min()
            .ok_or(CallError::InvalidSampleCount)?;
        let range = self
            .thresholds
            .partition_point(|threshold| *threshold <= minimum_depth);
        let can_collapse = is_reference(&site) && range != 0;
        if can_collapse
            && site.samples().iter().any(|sample| {
                sample
                    .phred_likelihoods()
                    .is_some_and(|values| values.len() != 3)
            })
        {
            return Err(CallError::InvalidGvcfLikelihoods);
        }
        let needs_flush = self.block.as_ref().is_some_and(|block| {
            !can_collapse
                || block.range != range
                || block.site.reference_sequence_id() != site.reference_sequence_id()
                || site.position() > block.end.saturating_add(1)
        });

        if needs_flush {
            let same_end = self.block.as_ref().is_some_and(|block| {
                block.site.reference_sequence_id() == site.reference_sequence_id()
                    && block.end == site.position()
                    && block.end > block.site.position()
            });
            if let Some(block) = &mut self.block
                && same_end
            {
                block.end -= 1;
            }
            if let Some(block) = self.take_block() {
                emit(block)?;
            }
        }

        if can_collapse {
            match &mut self.block {
                Some(block) => block.extend(&site, minimum_depth)?,
                None => {
                    self.block = Some(Block {
                        end: site.position(),
                        site,
                        minimum_depth,
                        range,
                    });
                }
            }
        } else {
            if is_reference(&site) && minimum_depth != 0 {
                site.gvcf = Some(GvcfSite::new(None, minimum_depth, false));
            }
            emit(site)?;
        }
        Ok(())
    }

    pub fn finish(mut self, mut emit: impl FnMut(CalledSite) -> Result<()>) -> Result<()> {
        if let Some(site) = self.take_block() {
            emit(site)?;
        }
        Ok(())
    }

    fn take_block(&mut self) -> Option<CalledSite> {
        self.block.take().map(Block::finish)
    }
}

impl Block {
    fn extend(&mut self, site: &CalledSite, minimum_depth: u32) -> Result<()> {
        if self.site.samples.len() != site.samples.len() {
            return Err(CallError::GvcfSampleCountMismatch);
        }
        self.end = site.position();
        self.minimum_depth = self.minimum_depth.min(minimum_depth);
        for (sample, next) in self.site.samples.iter_mut().zip(site.samples()) {
            let depth = sample.evidence.depth().min(next.evidence().depth());
            sample.evidence.set_depth(depth);
            match (&mut sample.phred_likelihoods, next.phred_likelihoods()) {
                (Some(current), Some(next)) if current.len() == 3 && next.len() == 3 => {
                    if current[1] > next[1] {
                        current[1] = next[1];
                        current[2] = next[2];
                    } else if current[1] == next[1] {
                        current[2] = current[2].min(next[2]);
                    }
                }
                (Some(_), Some(_)) => return Err(CallError::InvalidGvcfLikelihoods),
                (current, None) => *current = None,
                (None, Some(_)) => {}
            }
        }
        Ok(())
    }

    fn finish(mut self) -> CalledSite {
        let end_position = (self.end > self.site.position()).then_some(self.end);
        self.site.quality = None;
        self.site.indel_summary = None;
        self.site.annotations = None;
        self.site.prior_allele_counts = None;
        self.site.gvcf = Some(GvcfSite::new(end_position, self.minimum_depth, true));
        self.site
    }
}

fn is_reference(site: &CalledSite) -> bool {
    !site.is_variant()
        && site.alternates().is_empty()
        && site.samples().iter().all(|sample| {
            sample
                .genotype()
                .is_none_or(|genotype| genotype.iter().all(|allele| *allele == 0))
        })
}

#[cfg(test)]
mod tests;