chromsize 0.0.33

but first, how is this better than any other option? yeah, just check the image below.

googled 'get chromosome sizes from fasta', grab every command/tool I found and benchmarked it. surprisingly, you can lose 14 seconds of your life just waiting for those chrom sizes to be calculated. crazy.

What's new on v.0.0.33?

• --fasta now is --sequence, change based on .fa/.fa.gz/.2bit inputs
• implementation of stdin mode!
• --sequence now defaults to -, so omitting it reads stdin; help text mentions stdin.
• SIMD newline/CR counting via bytecount
• Switched gzip inflate to flate2 with the faster zlib-ng-compat backend and enlarged output buffering

Usage

Binary

Usage: chromsize [--sequence <SEQUENCE>] --output <OUTPUT> [-t <THREADS>]

Arguments:
    -s, --sequence <SEQUENCE>: Sequence file (FASTA/2bit, use '-' or omit to read stdin) [default: -]
    -o, --output <OUTPUT>: path to chrom.sizes

Options:
    -t, --threads <THREADS>: number of threads [default: your max ncpus]
    -a, --accession-only     only keep the accession id part of the header (stop after blank)
    --help: print help
    --version: print version

examples:

• stream: cat genome.fa | chromsize -o tmp.chromsizes
• explicit stdin: zcat genome.fa.gz | chromsize -o tmp.chromsizes -s -
• file input: chromsize -s genome.fa -o tmp.chromsizes

input format (FASTA/2bit) and gzip compression are auto-detected (from files or stdin) even if the extension is missing.

crate: https://crates.io/crates/chromsize

Installation

to install rust and use chromsize on your system follow this steps:

1. get installer: curl https://sh.rustup.rs -sSf | sh on unix, or go here for other options
2. run cargo install chromsize (make sure ~/.cargo/bin is in your $PATH before running it)
3. use chromsize with the required arguments

Library

use chromsize;

fn main() {
    let input = PathBuf::new("/path/to/genome.fa");
    let output = PathBuf::new("/path/to/chrom.sizes");

    let sizes: Vec<(String, u64)> = chromsize::get_sizes(&input).expect("failed to read sequence");
    chromsize::writer(&sizes, &output).expect("failed to write chrom sizes");
}

Python

build the port to install it as a pkg:

git clone https://github.com/alejandrogzi/chromsize.git && cd chromsize/py-chromsize
hatch shell
maturin develop --release

use it as a binary wrapper [for .fa and .2bit]:

import chromsize as cs

input = "/path/to/genome.fa"
output = "/path/to/chrom.sizes"
cs.write_chromsizes(input, output)

or just get them directly

import chromsize as cs

input = "/path/to/genome.fa"
sizes = cs.get_chromsizes(input)

>>> print(sizes)
[
    ('chr1', 123),
    ('chr2', 456),
    ...
]

Build

to build chromsize from this repo, do:

1. get rust
2. run git clone https://github.com/alejandrogzi/chromsize.git && cd chromsize
3. run cargo run --release -- -s <SEQUENCE> -o <OUTPUT>

Container image

to build the development container image:

1. run git clone https://github.com/alejandrogzi/chromsize.git && cd chromsize
2. initialize docker with start docker or systemctl start docker
3. build the image docker image build --tag chromsize .
4. run docker run --rm -v "[dir_where_your_fa_is]:/dir" chromsize -s /dir/<SEQUENCE> -o /dir/<OUTPUT>

Conda

to use chromsize through Conda just:

1. conda install chromsize -c bioconda or conda create -n chromsize -c bioconda chromsize

Nextflow (not available yet)

Benchmark

do not believe me? run the benchmark on your own:

1. get .fa from any species you want (or download the ones I used from UCSC/NCBI)
2. install hyperfine: https://github.com/sharkdp/hyperfine
3. go to chromsize/bench and modify the ASSEMBLIES const with the .fa you've download
4. run cargo run release --bin chromsize-benchmark -- -d /dir/where/my/fastas/are -a show-output ignore-failure

here is all the info and metadata from my experiment:

which tools I used?

detailed data?

how well performs with .gz?

CHM13-T2T.fa.gz