kira-spliceqc 0.2.0

Deterministic, explainable splicing QC for single-cell expression 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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::path::PathBuf;

use clap::{Args, Parser, Subcommand, ValueEnum};
use kira_spliceqc::cli::config::{AnalysisMode, RunConfig, RunMode};
use kira_spliceqc::cli::run::{SpliceQcError, run_pipeline};
use tracing_subscriber::EnvFilter;

#[derive(Parser)]
#[command(name = "kira-spliceqc", version, author)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Option<Commands>,
    #[command(flatten)]
    pub run: RunArgs,
}

#[derive(Subcommand)]
pub enum Commands {
    Run(RunArgs),
}

#[derive(ValueEnum, Clone, Copy)]
pub enum ModeArg {
    Cell,
    Sample,
}

#[derive(ValueEnum, Clone, Copy)]
pub enum RunModeArg {
    Standalone,
    Pipeline,
}

#[derive(Args, Clone)]
pub struct RunArgs {
    #[arg(long)]
    pub input: Option<PathBuf>,
    #[arg(long)]
    pub out: Option<PathBuf>,
    #[arg(long)]
    pub cache: Option<PathBuf>,
    #[arg(long, value_enum, default_value = "cell")]
    pub mode: ModeArg,
    #[arg(long)]
    pub json: bool,
    #[arg(long)]
    pub tsv: bool,
    #[arg(long)]
    pub extended: bool,
    #[arg(long)]
    pub threads: Option<usize>,
    #[arg(long, value_enum, default_value = "standalone")]
    pub run_mode: RunModeArg,
}

fn main() {
    let cli = Cli::parse();
    init_tracing();

    let run_args = match cli.command {
        Some(Commands::Run(args)) => args,
        None => cli.run,
    };

    let result = execute_run(run_args);

    if let Err(err) = result {
        handle_error(err);
    }
}

fn init_tracing() {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
    tracing_subscriber::fmt().with_env_filter(filter).init();
}

fn handle_error(err: SpliceQcError) -> ! {
    match err {
        SpliceQcError::InvalidInput(msg) => {
            eprintln!("error: {msg}");
            std::process::exit(1);
        }
        SpliceQcError::Io(io) => {
            eprintln!("error: {io}");
            std::process::exit(1);
        }
        SpliceQcError::PipelineFailure(msg) => {
            eprintln!("error: {msg}");
            std::process::exit(2);
        }
    }
}

fn execute_run(args: RunArgs) -> Result<(), SpliceQcError> {
    let input = args
        .input
        .ok_or_else(|| SpliceQcError::InvalidInput("--input is required".to_string()))?;
    let out = args
        .out
        .ok_or_else(|| SpliceQcError::InvalidInput("--out is required".to_string()))?;

    let config = RunConfig {
        input,
        out_dir: out,
        cache_path: args.cache,
        mode: match args.mode {
            ModeArg::Cell => AnalysisMode::Cell,
            ModeArg::Sample => AnalysisMode::Sample,
        },
        run_mode: match args.run_mode {
            RunModeArg::Standalone => RunMode::Standalone,
            RunModeArg::Pipeline => RunMode::Pipeline,
        },
        output_json: args.json,
        output_tsv: args.tsv,
        extended: args.extended,
        threads: args.threads,
    };
    run_pipeline(config)
}