segul 0.23.2

An ultrafast and memory-efficient tool for phylogenomics
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



use std::path::PathBuf;

use clap::{builder, Args, Subcommand};
use clap::builder::TypedValueParser as _;

use crate::helper::types::{ContigFmt, SeqReadFmt, SummaryMode};

use super::IOArgs;


#[derive(Subcommand)]
pub(crate) enum SeqReadSubcommand {
    #[command(about = "Compute sequence read statistics", name = "summary")]
    RawSummary(SeqReadSummaryArgs),
}

#[derive(Subcommand)]
pub(crate) enum ContigSubcommand {
    #[command(about = "Compute contig statistics", name = "summary")]
    ContigSummary(ContigSummaryArgs),
}

#[derive(Subcommand)]
pub(crate) enum MafSubcommand {
    #[command(about = "Convert genomic files to other formats", name = "maf")]
    Maf(MafConvertArgs),
}


#[derive(Args)]
pub(crate) struct SeqReadSummaryArgs {
    #[command(flatten)]
    pub(crate) io: IOArgs,
    #[arg(
        short = 'f', 
        long ="input-format", 
        help = "Specify input format", 
        default_value_t = SeqReadFmt::Auto,
        value_parser = 
            builder::PossibleValuesParser::new(["auto","fastq","gzip"])
            .map(|x| x.parse::<SeqReadFmt>().expect("Invalid input format")),
    )]
    pub(crate) input_format: SeqReadFmt,
    #[arg(
        long = "mode", 
        help = "Summary mode", 
        default_value_t = SummaryMode::Default,
        value_parser = 
            builder::PossibleValuesParser::new(["minimal", "default", "complete"])
            .map(|x| x.parse::<SummaryMode>().unwrap()))]
    pub(crate) mode: SummaryMode,
    #[arg(short = 'o', long = "output", help = "Output path", default_value = "Read-Summary")]
    pub(crate) output: PathBuf,
    #[arg(long = "prefix", help = "Specify prefix for output files")]
    pub(crate) prefix: Option<String>,
}

#[derive(Args)]
pub(crate) struct ContigSummaryArgs {
    #[command(flatten)]
    pub(crate) io: IOArgs,
    #[arg(
        short = 'f', 
        long ="input-format", 
        help = "Specify input format", 
        default_value_t = ContigFmt::Auto,
        value_parser = 
            builder::PossibleValuesParser::new(["auto","fasta","gzip"])
            .map(|x| x.parse::<ContigFmt>().expect("Invalid input format")),
    )]
    pub(crate) input_format: ContigFmt,
    #[arg(short = 'o', long = "output", help = "Output path", default_value = "Contig-Summary")]
    pub(crate) output: PathBuf,
    #[arg(long = "prefix", help = "Specify prefix for output files")]
    pub(crate) prefix: Option<String>,
}

#[derive(Args)]
pub(crate) struct MafConvertArgs {
    #[command(flatten)]
    pub(crate) io: IOArgs,
    #[arg(long, help = "Path to the source of reference names")]
    pub(crate) reference: PathBuf,
    #[arg(long, help = "Source of names is a bed file")]
    pub(crate) from_bed: bool,
    #[arg(
        short = 't', 
        long = "output-format", 
        help = "Specify output format", 
        default_value = "fasta-int",
        value_parser = 
            builder::PossibleValuesParser::new(["fasta", "phylip","fasta-int", "phylip-int"]),
    )]
    pub(crate) output_fmt: String,
    #[arg(short = 'o', long = "output", help = "Output path", default_value = "Genomic-Convert")]
    pub(crate) output: PathBuf,
    #[arg(long = "prefix", help = "Specify prefix for output files")]
    pub(crate) prefix: Option<String>,
}