Enum Commands

pub enum Commands {
    Stats {
        bam: String,
        qbed: bool,
        paf: bool,
    },
    BedLength {
        bed: Vec<String>,
        readable: bool,
        column: Option<u8>,
    },
    Filter {
        paf: String,
        paired_len: u64,
        aln: u64,
        query: u64,
    },
    Invert {
        paf: String,
    },
    Liftover {
        paf: String,
        bed: String,
        qbed: bool,
        largest: bool,
    },
    TrimPaf {
        paf: String,
        match_score: i32,
        diff_score: i32,
        indel_score: i32,
        remove_contained: bool,
    },
    Orient {
        paf: String,
        scaffold: bool,
        insert: u64,
    },
    BreakPaf {
        paf: String,
        max_size: u32,
    },
    PafToSam {
        paf: String,
        fasta: Option<String>,
    },
    FastxSplit {
        fastx: Vec<String>,
    },
    GetFasta {
        fasta: String,
        bed: String,
        strand: bool,
        name: bool,
    },
    Nucfreq {
        bam: String,
        region: Option<String>,
        bed: Option<String>,
        small: bool,
    },
    Repeat {
        fasta: String,
        min: usize,
    },
    Suns {
        fasta: String,
        kmer_size: usize,
        max_size: usize,
        validate: bool,
    },
    AddRg {
        source: String,
        threads: usize,
        uncompressed: bool,
        sample: Option<String>,
    },
    SeqStats {
        infiles: Vec<String>,
        threads: usize,
        human: bool,
        quantiles: Vec<f64>,
        genome_size: Option<usize>,
    },
}

This structure contains all the subcommands for rustybam and their help descriptions.

Because of naming conventions for rust enums the commands names have different capitalization than on the command line. For example, the Liftover enum is invoked using rustybam liftover and the TrimPaf command with rustybam trim-paf.

Variants

Stats

Get percent identity stats from a sam/bam/cram or PAF. Requires =/X operations in the CIGAR string!

output column descriptions:

perID_by_matches is calculated as:

matches / (matches + mismatches)

perID_by_events is calculated as:

matches / (matches + mismatches + insertion events + deletion events)

perID_by_all is calculated as:

matches / (matches + mismatches + insertion bases + deletion bases)

Fields

bam: String

Input sam/bam/cram/file.

qbed: bool

Print query coordinates first

paf: bool

Specify that the input is paf format, (must have cg tag with extended cigar).

BedLength

Count the number of bases in a bed file.

Fields

bed: Vec<String>

Input bed file.

readable: bool

Make the output human readable (Mbp).

column: Option<u8>

Count bases for each category in this column .

Filter

Filter PAF records in various ways.

Fields

paf: String

PAF file from minimap2 or unimap. Must have the cg tag, and n matches will be zero unless the cigar uses =X.

paired_len: u64

Minimum number of aligned bases across all alignments between a target and query in order to keep those records.

aln: u64

Minimum alignment length.

query: u64

Minimum query length.

Invert

Invert the target and query sequences in a PAF along with the CIGAR string.

Fields

paf: String

PAF file from minimap2 or unimap. Must have the cg tag, and n matches will be zero unless the cigar uses =X.

Liftover

Liftover target sequence coordinates onto query sequence using a PAF.

This is a function for lifting over coordinates from a reference () to a query using a PAF file from minimap2 or unimap (note, you can use paftools.js sam2paf to convert SAM data to PAF format). The returned file is a PAF file that is trimmed to the regions in the bed file. Even the cigar in the returned PAF file is trimmed so it can be used downstream! Additionally, a tag with the format id:Z:<> is added to the PAF where <> is either the 4th column of the input bed file or if not present chr_start_end.

Fields

paf: String

PAF file from minimap2 or unimap run with -c and –eqx [i.e. the PAF file must have the cg tag and use extended CIGAR opts (=/X)].

bed: String

BED file of reference regions to liftover to the query.

qbed: bool

Specifies that the BED file contains query coordinates to be lifted onto the reference (reverses direction of liftover).

Note, that this will make the query in the input PAF the target in the output PAF.

largest: bool

If multiple records overlap the same region in the return only the largest liftover. The default is to return all liftovers.

TrimPaf

Trim PAF records that overlap in query sequence to find and optimal splitting point using dynamic programing.

Note, this can be combined with rb invert to also trim the target sequence.

This idea is to mimic some of the trimming that happens in PAV to improve breakpoint detection. Starts with the largest overlap and iterates until no query overlaps remain.

Fields

paf: String

PAF file from minimap2 or unimap. Must have the cg tag, and n matches will be zero unless the cigar uses =X.

match_score: i32

Value added for a matching base.

diff_score: i32

Value subtracted for a mismatching base.

indel_score: i32

Value subtracted for an insertion or deletion.

remove_contained: bool

Remove contained alignments as well as overlaps.

Orient

Orient paf records so that most of the bases are in the forward direction.

Optionally scaffold the queriers so that there is one query per target.

Fields

paf: String

PAF file from minimap2 or unimap. Must have the cg tag, and n matches will be zero unless the cigar uses =X.

scaffold: bool

Generate ~1 query per target that scaffolds together all the records that map to that target sequence.

The order of the scaffold will be determined by the average target position across all the queries, and the name of the new scaffold will be.

insert: u64

Space to add between records.

BreakPaf

Break PAF records with large indels into multiple records (useful for SafFire).

Fields

paf: String

PAF file from minimap2 or unimap. Must have the cg tag, and n matches will be zero unless the cigar uses =X.

max_size: u32

Maximum indel size to keep in the paf.

PafToSam

Convert a PAF file into a SAM file. Warning, all alignments will be marked as primary!

Fields

paf: String

PAF file from minimap2 or unimap. Must have a CIGAR tag.

fasta: Option<String>

Optional query fasta file (with index) to populate the query seq field.

FastxSplit

Splits fastx from stdin into multiple files.

Specifically it reads fastx format (fastq, fasta, or mixed) from stdin and divides the records across multiple output files. Output files can be compressed by adding .gz, and the input can also be compressed or uncompressed.

Fields

fastx: Vec<String>

List of fastx files to write to.

GetFasta

Mimic bedtools getfasta but allow for bgzip in both bed and fasta inputs.

Fields

fasta: String

Fasta file to extract sequences from.

bed: String

BED file of regions to extract.

strand: bool

Reverse complement the sequence if the strand is “-”.

name: bool

Add the name (4th column) to the header of the fasta output.

Nucfreq

Get the frequencies of each bp at each position.

Fields

bam: String

Input sam/bam/cram/file.

region: Option<String>

Print nucfreq info from the input region e.g “chr1:1-1000”.

bed: Option<String>

Print nucfreq info from regions in the bed file output is optionally tagged using the 4th column.

small: bool

Smaller output format.

Repeat

Report the longest exact repeat length at every position in a fasta.

Fields

fasta: String

Input fasta file.

min: usize

The smallest repeat length to report.

Suns

Extract the intervals in a genome (fasta) that are made up of SUNs.

Fields

fasta: String

Input fasta file with the genome.

kmer_size: usize

The size of the required unique kmer.

max_size: usize

The maximum size SUN interval to report.

validate: bool

Confirm all the SUNs (very slow) only for debugging.

AddRg

Add RG lines from a source BAM file to the BAM from stdin to the BAM going to stdout

Fields

source: String

Source BAM file to read RG lines from

threads: usize

Number of threads to use

uncompressed: bool

Write uncompressed output

sample: Option<String>

Add this string as the sample name (SM) to each read group in the output BAM

SeqStats

Calculate summary statistics from fasta/q, sam, bam, or bed files. e.g. N50, mean, quantiles.

Fields

infiles: Vec<String>

Input files (fast{a,q}(.gz), sam, bam, bed)

threads: usize

Number of threads to use

human: bool

Print human-readable output

quantiles: Vec<f64>

Quantiles to calculate

genome_size: Option<usize>

Genome size for NG50 calculation

Trait Implementations

impl Debug for Commands

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command<'b>) -> Command<'b>

Append to Command so it can instantiate Self.

fn augment_subcommands_for_update<'b>(__clap_app: Command<'b>) -> Command<'b>

Append to Command so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand