rsomics-annotation 0.1.0

Typed GFF3 and GTF validation, selection, conversion, and sequence extraction
Documentation
use std::io::{BufRead, Write};
use std::path::Path;

use rsomics_common::{Context, Result, RsomicsError};

use crate::annotation::Dialect;
use crate::fasta::write_record;
use crate::genome::Genome;
use crate::splice::splice;
use crate::transcript::{Span, load};
use crate::translation::translate;

pub(crate) struct Options {
    pub(crate) omit_coding_range: bool,
    pub(crate) star_stop: bool,
}

pub(crate) struct Outputs<'a> {
    pub(crate) transcripts: Option<&'a mut dyn Write>,
    pub(crate) coding: Option<&'a mut dyn Write>,
    pub(crate) proteins: Option<&'a mut dyn Write>,
}

pub(crate) fn extract<R: BufRead>(
    input: R,
    dialect: Dialect,
    genome_path: &Path,
    options: &Options,
    outputs: &mut Outputs<'_>,
) -> Result<()> {
    if outputs.transcripts.is_none() && outputs.coding.is_none() && outputs.proteins.is_none() {
        return Err(RsomicsError::ConfigError(
            "extract requires at least one FASTA output".to_owned(),
        ));
    }

    let transcripts = load(input, dialect)?;
    let mut genome = Genome::open(genome_path)?;
    let mut current_seqid = Vec::new();
    let mut chromosome = Vec::new();
    let mut record_scratch = Vec::new();
    let mut name_scratch = Vec::new();
    for transcript in transcripts {
        if transcript.seqid != current_seqid {
            chromosome = genome.read_sequence(&transcript.seqid)?;
            current_seqid.clone_from(&transcript.seqid);
        }

        let full_span = Span {
            start: transcript.exons[0].start,
            end: transcript.exons[transcript.exons.len() - 1].end,
        };
        if full_span.end > chromosome.len() as u64 {
            return Err(RsomicsError::InvalidInput(format!(
                "transcript {:?} ends at {}, beyond sequence {:?} length {}",
                String::from_utf8_lossy(&transcript.id),
                full_span.end,
                String::from_utf8_lossy(&transcript.seqid),
                chromosome.len()
            )));
        }

        if let Some(output) = outputs.transcripts.as_deref_mut() {
            let spliced = splice(
                &chromosome,
                &transcript.exons,
                transcript.reverse,
                full_span,
                transcript.coding,
            );
            name_scratch.clear();
            name_scratch.extend_from_slice(&transcript.id);
            if let Some((start, end)) = spliced.coding_range
                && !options.omit_coding_range
            {
                write!(name_scratch, " CDS={start}-{end}")
                    .rs_context("formatting transcript FASTA name")?;
            }
            write_record(
                output,
                &mut record_scratch,
                &name_scratch,
                &spliced.sequence,
                false,
            )?;
        }

        if let Some(coding_span) = transcript.coding
            && (outputs.coding.is_some() || outputs.proteins.is_some())
        {
            let spliced = splice(
                &chromosome,
                &transcript.exons,
                transcript.reverse,
                coding_span,
                None,
            );
            if let Some(output) = outputs.coding.as_deref_mut() {
                write_record(
                    output,
                    &mut record_scratch,
                    &transcript.id,
                    &spliced.sequence,
                    false,
                )?;
            }
            if let Some(output) = outputs.proteins.as_deref_mut() {
                let protein = translate(&spliced.sequence);
                write_record(
                    output,
                    &mut record_scratch,
                    &transcript.id,
                    &protein,
                    options.star_stop,
                )?;
            }
        }
    }

    if let Some(output) = outputs.transcripts.as_mut() {
        output
            .flush()
            .rs_context("flushing transcript FASTA output")?;
    }
    if let Some(output) = outputs.coding.as_mut() {
        output.flush().rs_context("flushing coding FASTA output")?;
    }
    if let Some(output) = outputs.proteins.as_mut() {
        output.flush().rs_context("flushing protein FASTA output")?;
    }
    Ok(())
}