redicat 0.4.2

REDICAT - RNA Editing Cellular Assessment Toolkit: A highly parallelized utility for analyzing RNA editing events in single-cell RNA-seq data
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

mod args;
mod processor;

use anyhow::Result;
use log::info;
use redicat_lib::core::read_filter::DefaultReadFilter;
use redicat_lib::engine::{par_granges, ParGranges};
use redicat_lib::utils;
use std::sync::Arc;

use crate::commands::{common, is_standard_contig};

pub use args::{BulkArgs, BulkConfig};
use processor::BaseProcessor;

/// Execute the `bulk` command end-to-end.
pub fn run_bulk(args: BulkArgs) -> Result<()> {
    let config: BulkConfig = args.into();
    config.validate()?;

    info!("Running redicat bulk on {:?}", config.reads);
    let threads = utils::determine_allowed_cpus(config.threads)?;

    let output_path = common::ensure_gz_path(&config.output);
    utils::make_parent_dirs(&output_path)?;

    let mut writer = utils::get_writer(&Some(output_path.clone()), true, true, 1, 6)?;

    let read_filter = Arc::new(DefaultReadFilter::new(config.mapquality));

    let allowed_tids = if config.all_contigs {
        None
    } else {
        Some(common::collect_tids_with_filter(&config.reads, |name| {
            is_standard_contig(name)
        })?)
    };

    let processor = BaseProcessor::from_config(&config, read_filter, allowed_tids);

    let runner = ParGranges::new(
        config.reads.clone(),
        None,
        None,
        None,
        false,
        Some(threads),
        Some(config.chunksize),
        Some(par_granges::CHANNEL_SIZE_MODIFIER),
        processor,
    );

    let receiver = runner.process()?;
    for pos in receiver.into_iter() {
        writer.serialize(pos)?;
    }

    writer.flush()?;
    info!("Bulk processing complete -> {:?}", output_path);
    Ok(())
}