rosella 0.5.7

Metagenome assembled genome recovery from metagenomes using UMAP and HDBSCAN
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

use clap::{crate_version, crate_name};
use clap_complete::{generate, Shell};
use env_logger::Builder;
use log::{LevelFilter, info, error};
use std::env;

#[cfg(not(feature = "no_flight"))]
use rosella::refine::refinery::run_refine;
use rosella::cli::{build_cli, refine_full_help, recover_full_help};
use rosella::recover::recover_engine::run_recover;

use bird_tool_utils::clap_utils::print_full_help_if_needed;

fn main() {
    let mut app = build_cli();
    let matches = app.clone().get_matches();

    match matches.subcommand_name() {
        Some("recover") => {
            let sub_matches = matches.subcommand_matches("recover").unwrap();
            print_full_help_if_needed(sub_matches, recover_full_help());
            set_log_level(&sub_matches, true);
            // set rayon threads
            let threads = *sub_matches.get_one::<usize>("threads").unwrap();
            rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
            match run_recover(sub_matches) {
                Ok(_) => {}
                Err(e) => {
                    error!("Recover Failed with error: {}", e);
                    std::process::exit(1);
                }
            };
        },
        Some("refine") => {
            #[cfg(feature = "no_flight")]
            {
                let sub_matches = matches.subcommand_matches("refine").unwrap();
                print_full_help_if_needed(sub_matches, refine_full_help());
                set_log_level(&sub_matches, true);
                // set rayon threads
                let threads = *sub_matches.get_one::<usize>("threads").unwrap();
                rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
                error!("Refine is not available in this version of rosella");
                error!("Recompile without the 'no_flight' feature and install flight via GitHub");
                unimplemented!();
            }

            #[cfg(not(feature = "no_flight"))]
            {
                let sub_matches = matches.subcommand_matches("refine").unwrap();
                print_full_help_if_needed(sub_matches, refine_full_help());
                set_log_level(&sub_matches, true);
                // set rayon threads
                let threads = *sub_matches.get_one::<usize>("threads").unwrap();
                rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
                match run_refine(sub_matches) {
                    Ok(_) => {}
                    Err(e) => {
                        error!("Refine Failed with error: {}", e);
                        std::process::exit(1);
                    }
                };
            }
        },
        Some("shell-completion") => {
            let m = matches.subcommand_matches("shell-completion").unwrap();
            set_log_level(m, true);
            let mut file = std::fs::File::create(m.get_one::<String>("output-file").unwrap())
                .expect("failed to open output file");

            if let Some(generator) = m.get_one::<Shell>("shell").copied() {
                let mut cmd = build_cli();
                info!("Generating completion script for shell {}", generator);
                let name = cmd.get_name().to_string();
                generate(generator, &mut cmd, name, &mut file);
            }
        }
        _ => {
            app.print_help().unwrap();
            std::process::exit(1);
        }
    }
}


fn set_log_level(matches: &clap::ArgMatches, is_last: bool) {
    let mut log_level = LevelFilter::Info;
    let mut specified = false;
    if matches.get_flag("verbose") {
        specified = true;
        log_level = LevelFilter::Debug;
    }
    if matches.get_flag("quiet") {
        specified = true;
        log_level = LevelFilter::Error;
    }
    if specified || is_last {
        let mut builder = Builder::new();
        builder.filter_level(log_level);
        builder.filter_module("annembed", LevelFilter::Off);
        builder.filter_module("hnsw_rs", LevelFilter::Off);
        if env::var("RUST_LOG").is_ok() {
            builder.parse_filters(&env::var("RUST_LOG").unwrap());
        }
        if builder.try_init().is_err() {
            panic!("Failed to set log level - has it been specified multiple times?")
        }
    }
    if is_last {
        info!("{} version {}", crate_name!(), crate_version!());
    }
}