minimap2 0.2.30.3 → 1.2.31.0

data/ext/minimap2/pyproject.toml

@@ -1,2 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel", "Cython"]

data/ext/minimap2/python/README.rst

@@ -1,198 +0,0 @@
-==============================
-Mappy: Minimap2 Python Binding
-==============================
-
-Mappy provides a convenient interface to `minimap2
-<https://github.com/lh3/minimap2>`_, a fast and accurate C program to align
-genomic and transcribe nucleotide sequences.
-
-Installation
-------------
-
-Mappy depends on `zlib <http://zlib.net>`_. It can be installed with `pip
-<https://en.wikipedia.org/wiki/Pip_(package_manager)>`_:
-
-.. code:: shell
-
-	pip install --user mappy
-
-or from the minimap2 github repo (`Cython <http://cython.org>`_ required):
-
-.. code:: shell
-
-	git clone https://github.com/lh3/minimap2
-	cd minimap2
-	python setup.py install
-
-Usage
------
-
-The following Python script demonstrates the key functionality of mappy:
-
-.. code:: python
-
-	import mappy as mp
-	a = mp.Aligner("test/MT-human.fa")  # load or build index
-	if not a: raise Exception("ERROR: failed to load/build index")
-	s = a.seq("MT_human", 100, 200)     # retrieve a subsequence from the index
-	print(mp.revcomp(s))                # reverse complement
-	for name, seq, qual in mp.fastx_read("test/MT-orang.fa"): # read a fasta/q sequence
-		for hit in a.map(seq): # traverse alignments
-			print("{}\t{}\t{}\t{}".format(hit.ctg, hit.r_st, hit.r_en, hit.cigar_str))
-
-APIs
-----
-
-Mappy implements two classes and two global function.
-
-Class mappy.Aligner
-~~~~~~~~~~~~~~~~~~~
-
-.. code:: python
-
-	mappy.Aligner(fn_idx_in=None, preset=None, ...)
-
-This constructor accepts the following arguments:
-
-* **fn_idx_in**: index or sequence file name. Minimap2 automatically tests the
-  file type. If a sequence file is provided, minimap2 builds an index. The
-  sequence file can be optionally gzip'd. This option has no effect if **seq**
-  is set.
-
-* **seq**: a single sequence to index. The sequence name will be set to
-  :code:`N/A`.
-
-* **preset**: minimap2 preset. Currently, minimap2 supports the following
-  presets: **sr** for single-end short reads; **map-pb** for PacBio
-  read-to-reference mapping; **map-ont** for Oxford Nanopore read mapping;
-  **splice** for long-read spliced alignment; **asm5** for assembly-to-assembly
-  alignment; **asm10** for full genome alignment of closely related species. Note
-  that the Python module does not support all-vs-all read overlapping.
-
-* **k**: k-mer length, no larger than 28
-
-* **w**: minimizer window size, no larger than 255
-
-* **min_cnt**: mininum number of minimizers on a chain
-
-* **min_chain_score**: minimum chaing score
-
-* **bw**: chaining and alignment band width (initial chaining and extension)
-
-* **bw_long**: chaining and alignment band width (RMQ-based rechaining and closing gaps)
-
-* **best_n**: max number of alignments to return
-
-* **n_threads**: number of indexing threads; 3 by default
-
-* **extra_flags**: additional flags defined in minimap.h
-
-* **fn_idx_out**: name of file to which the index is written. This parameter
-  has no effect if **seq** is set.
-
-* **scoring**: scoring system. It is a tuple/list consisting of 4, 6 or 7
-  positive integers. The first 4 elements specify match scoring, mismatch
-  penalty, gap open and gap extension penalty. The 5th and 6th elements, if
-  present, set long-gap open and long-gap extension penalty. The 7th sets a
-  mismatch penalty involving ambiguous bases.
-
-.. code:: python
-
-	mappy.Aligner.map(seq, seq2=None, cs=False, MD=False)
-
-This method aligns :code:`seq` against the index. It is a generator, *yielding*
-a series of :code:`mappy.Alignment` objects. If :code:`seq2` is present, mappy
-performs paired-end alignment, assuming the two ends are in the FR orientation.
-Alignments of the two ends can be distinguished by the :code:`read_num` field
-(see Class mappy.Alignment below). Argument :code:`cs` asks mappy to generate
-the :code:`cs` tag; :code:`MD` is similar. These two arguments might slightly
-degrade performance and are not enabled by default.
-
-.. code:: python
-
-	mappy.Aligner.seq(name, start=0, end=0x7fffffff)
-
-This method retrieves a (sub)sequence from the index and returns it as a Python
-string. :code:`None` is returned if :code:`name` is not present in the index or
-the start/end coordinates are invalid.
-
-.. code:: python
-
-	mappy.Aligner.seq_names
-
-This property gives the array of sequence names in the index.
-
-Class mappy.Alignment
-~~~~~~~~~~~~~~~~~~~~~
-
-This class describes an alignment. An object of this class has the following
-properties:
-
-* **ctg**: name of the reference sequence the query is mapped to
-
-* **ctg_len**: total length of the reference sequence
-
-* **r_st** and **r_en**: start and end positions on the reference
-
-* **q_st** and **q_en**: start and end positions on the query
-
-* **strand**: +1 if on the forward strand; -1 if on the reverse strand
-
-* **mapq**: mapping quality
-
-* **blen**: length of the alignment, including both alignment matches and gaps
-  but excluding ambiguous bases.
-
-* **mlen**: length of the matching bases in the alignment, excluding ambiguous
-  base matches.
-
-* **NM**: number of mismatches, gaps and ambiguous positions in the alignment
-
-* **trans_strand**: transcript strand. +1 if on the forward strand; -1 if on the
-  reverse strand; 0 if unknown
-
-* **is_primary**: if the alignment is primary (typically the best and the first
-  to generate)
-
-* **read_num**: read number that the alignment corresponds to; 1 for the first
-  read and 2 for the second read
-
-* **cigar_str**: CIGAR string
-
-* **cigar**: CIGAR returned as an array of shape :code:`(n_cigar,2)`. The two
-  numbers give the length and the operator of each CIGAR operation.
-
-* **MD**: the :code:`MD` tag as in the SAM format. It is an empty string unless
-  the :code:`MD` argument is applied when calling :code:`mappy.Aligner.map()`.
-
-* **cs**: the :code:`cs` tag.
-
-An :code:`Alignment` object can be converted to a string with :code:`str()` in
-the following format:
-
-::
-
-	q_st  q_en  strand  ctg  ctg_len  r_st  r_en  mlen  blen  mapq  cg:Z:cigar_str
-
-It is effectively the PAF format without the QueryName and QueryLength columns
-(the first two columns in PAF).
-
-Miscellaneous Functions
-~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: python
-
-	mappy.fastx_read(fn, read_comment=False)
-
-This generator function opens a FASTA/FASTQ file and *yields* a
-:code:`(name,seq,qual)` tuple for each sequence entry. The input file may be
-optionally gzip'd. If :code:`read_comment` is True, this generator yields
-a :code:`(name,seq,qual,comment)` tuple instead.
-
-.. code:: python
-
-	mappy.revcomp(seq)
-
-Return the reverse complement of DNA string :code:`seq`. This function
-recognizes IUB code and preserves the letter cases. Uracil :code:`U` is
-complemented to :code:`A`.

data/ext/minimap2/python/cmappy.h

@@ -1,152 +0,0 @@
-#ifndef CMAPPY_H
-#define CMAPPY_H
-
-#include <stdlib.h>
-#include <string.h>
-#include <zlib.h>
-#include "minimap.h"
-#include "kseq.h"
-KSEQ_DECLARE(gzFile)
-
-typedef struct {
-	const char *ctg;
-	int32_t ctg_start, ctg_end;
-	int32_t qry_start, qry_end;
-	int32_t blen, mlen, NM, ctg_len;
-	uint8_t mapq, is_primary;
-	int8_t strand, trans_strand;
-	int32_t seg_id;
-	int32_t n_cigar32;
-	uint32_t *cigar32;
-} mm_hitpy_t;
-
-static inline void mm_reg2hitpy(const mm_idx_t *mi, mm_reg1_t *r, mm_hitpy_t *h)
-{
-	h->ctg = mi->seq[r->rid].name;
-	h->ctg_len = mi->seq[r->rid].len;
-	h->ctg_start = r->rs, h->ctg_end = r->re;
-	h->qry_start = r->qs, h->qry_end = r->qe;
-	h->strand = r->rev? -1 : 1;
-	h->mapq = r->mapq;
-	h->mlen = r->mlen;
-	h->blen = r->blen;
-	h->NM = r->blen - r->mlen + r->p->n_ambi;
-	h->trans_strand = r->p->trans_strand == 1? 1 : r->p->trans_strand == 2? -1 : 0;
-	h->is_primary = (r->id == r->parent);
-	h->seg_id = r->seg_id;
-	h->n_cigar32 = r->p->n_cigar;
-	h->cigar32 = r->p->cigar;
-}
-
-static inline void mm_free_reg1(mm_reg1_t *r)
-{
-	free(r->p);
-}
-
-static inline kseq_t *mm_fastx_open(const char *fn)
-{
-	gzFile fp;
-	fp = fn && strcmp(fn, "-") != 0? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
-	return kseq_init(fp);
-}
-
-static inline void mm_fastx_close(kseq_t *ks)
-{
-	gzFile fp;
-	fp = ks->f->f;
-	kseq_destroy(ks);
-	gzclose(fp);
-}
-
-static inline int mm_verbose_level(int v)
-{
-	if (v >= 0) mm_verbose = v;
-	return mm_verbose;
-}
-
-static inline void mm_reset_timer(void)
-{
-	extern double realtime(void);
-	mm_realtime0 = realtime();
-}
-
-extern unsigned char seq_comp_table[256];
-static inline mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char* seqname, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
-{
-	mm_reg1_t *r;
-
-	Py_BEGIN_ALLOW_THREADS
-	if (seq2 == 0) {
-		r = mm_map(mi, strlen(seq1), seq1, n_regs, b, opt, seqname);
-	} else {
-		int _n_regs[2];
-		mm_reg1_t *regs[2];
-		char *seq[2];
-		int i, len[2];
-
-		len[0] = strlen(seq1);
-		len[1] = strlen(seq2);
-		seq[0] = (char*)seq1;
-		seq[1] = strdup(seq2);
-		for (i = 0; i < len[1]>>1; ++i) {
-			int t = seq[1][len[1] - i - 1];
-			seq[1][len[1] - i - 1] = seq_comp_table[(uint8_t)seq[1][i]];
-			seq[1][i] = seq_comp_table[t];
-		}
-		if (len[1]&1) seq[1][len[1]>>1] = seq_comp_table[(uint8_t)seq[1][len[1]>>1]];
-		mm_map_frag(mi, 2, len, (const char**)seq, _n_regs, regs, b, opt, seqname);
-		for (i = 0; i < _n_regs[1]; ++i)
-			regs[1][i].rev = !regs[1][i].rev;
-		*n_regs = _n_regs[0] + _n_regs[1];
-		regs[0] = (mm_reg1_t*)realloc(regs[0], sizeof(mm_reg1_t) * (*n_regs));
-		memcpy(&regs[0][_n_regs[0]], regs[1], _n_regs[1] * sizeof(mm_reg1_t));
-		free(regs[1]);
-		r = regs[0];
-	}
-	Py_END_ALLOW_THREADS
-
-	return r;
-}
-
-static inline char *mappy_revcomp(int len, const uint8_t *seq)
-{
-	int i;
-	char *rev;
-	rev = (char*)malloc(len + 1);
-	for (i = 0; i < len; ++i)
-		rev[len - i - 1] = seq_comp_table[seq[i]];
-	rev[len] = 0;
-	return rev;
-}
-
-static char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int *len)
-{
-	int i, rid;
-	char *s;
-	*len = 0;
-	rid = mm_idx_name2id(mi, name);
-	if (rid < 0) return 0;
-	if ((uint32_t)st >= mi->seq[rid].len || st >= en) return 0;
-	if (en < 0 || (uint32_t)en > mi->seq[rid].len)
-		en = mi->seq[rid].len;
-	s = (char*)malloc(en - st + 1);
-	*len = mm_idx_getseq(mi, rid, st, en, (uint8_t*)s);
-	for (i = 0; i < *len; ++i)
-		s[i] = "ACGTN"[(uint8_t)s[i]];
-	s[*len] = 0;
-	return s;
-}
-
-static mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int len)
-{
-	const char *fake_name = "N/A";
-	char *s;
-	mm_idx_t *mi;
-	s = (char*)calloc(len + 1, 1);
-	memcpy(s, seq, len);
-	mi = mm_idx_str(w, k, is_hpc, bucket_bits, 1, (const char**)&s, (const char**)&fake_name);
-	free(s);
-	return mi;
-}
-
-#endif

data/ext/minimap2/python/cmappy.pxd

@@ -1,156 +0,0 @@
-from libc.stdint cimport int8_t, uint8_t, int32_t, int64_t, uint32_t, uint64_t
-
-cdef extern from "minimap.h":
-	#
-	# Options
-	#
-	ctypedef struct mm_idxopt_t:
-		short k, w, flag, bucket_bits
-		int64_t mini_batch_size
-		uint64_t batch_size
-
-	ctypedef struct mm_mapopt_t:
-		int64_t flag
-		int seed
-		int sdust_thres
-
-		int max_qlen
-
-		int bw, bw_long
-		int max_gap, max_gap_ref
-		int max_frag_len
-		int max_chain_skip, max_chain_iter
-		int min_cnt
-		int min_chain_score
-		float chain_gap_scale
-		float chain_skip_scale
-		int rmq_size_cap, rmq_inner_dist
-		int rmq_rescue_size
-		float rmq_rescue_ratio
-
-		float mask_level
-		int mask_len
-		float pri_ratio
-		int best_n
-
-		float alt_drop
-
-		int a, b, q, e, q2, e2
-		int transition
-		int sc_ambi
-		int noncan
-		int junc_bonus, junc_pen
-		int zdrop, zdrop_inv
-		int end_bonus
-		int min_dp_max
-		int min_ksw_len
-		int anchor_ext_len, anchor_ext_shift
-		float max_clip_ratio
-
-		int rank_min_len
-		float rank_frac
-
-		int pe_ori, pe_bonus
-
-		int jump_min_match;
-
-		float mid_occ_frac
-		float q_occ_frac
-		int32_t min_mid_occ
-		int32_t mid_occ
-		int32_t max_occ
-		int64_t mini_batch_size
-		int64_t max_sw_mat
-		int64_t cap_kalloc
-
-		const char *split_prefix
-
-	int mm_set_opt(char *preset, mm_idxopt_t *io, mm_mapopt_t *mo)
-	int mm_verbose
-
-	#
-	# Indexing
-	#
-	ctypedef struct mm_idx_seq_t:
-		char *name
-		uint64_t offset
-		uint32_t len
-
-	ctypedef struct mm_idx_bucket_t:
-		pass
-
-	ctypedef struct mm_idx_t:
-		int32_t b, w, k, flag
-		uint32_t n_seq
-		mm_idx_seq_t *seq
-		uint32_t *S
-		mm_idx_bucket_t *B
-		void *km
-		void *h
-
-	ctypedef struct mm_idx_reader_t:
-		pass
-
-	mm_idx_reader_t *mm_idx_reader_open(const char *fn, const mm_idxopt_t *opt, const char *fn_out)
-	mm_idx_t *mm_idx_reader_read(mm_idx_reader_t *r, int n_threads)
-	void mm_idx_reader_close(mm_idx_reader_t *r)
-	void mm_idx_destroy(mm_idx_t *mi)
-	void mm_mapopt_update(mm_mapopt_t *opt, const mm_idx_t *mi)
-
-	int mm_idx_index_name(mm_idx_t *mi)
-
-	#
-	# Mapping (key struct defined in cmappy.h below)
-	#
-	ctypedef struct mm_reg1_t:
-		pass
-
-	ctypedef struct mm_tbuf_t:
-		pass
-
-	mm_tbuf_t *mm_tbuf_init()
-	void mm_tbuf_destroy(mm_tbuf_t *b)
-	void *mm_tbuf_get_km(mm_tbuf_t *b)
-	int mm_gen_cs(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden)
-	int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq)
-
-#
-# Helper header (because it is hard to expose mm_reg1_t with Cython)
-#
-cdef extern from "cmappy.h":
-	ctypedef struct mm_hitpy_t:
-		const char *ctg
-		int32_t ctg_start, ctg_end
-		int32_t qry_start, qry_end
-		int32_t blen, mlen, NM, ctg_len
-		uint8_t mapq, is_primary
-		int8_t strand, trans_strand
-		int32_t seg_id
-		int32_t n_cigar32
-		uint32_t *cigar32
-
-	void mm_reg2hitpy(const mm_idx_t *mi, mm_reg1_t *r, mm_hitpy_t *h)
-	void mm_free_reg1(mm_reg1_t *r)
-	mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char* seqname, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
-	char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int *l)
-	mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int l)
-
-	ctypedef struct kstring_t:
-		unsigned l, m
-		char *s
-
-	ctypedef struct kstream_t:
-		pass
-
-	ctypedef struct kseq_t:
-		kstring_t name, comment, seq, qual
-		int last_char
-		kstream_t *f
-
-	kseq_t *mm_fastx_open(const char *fn)
-	void mm_fastx_close(kseq_t *ks)
-	int kseq_read(kseq_t *seq)
-
-	char *mappy_revcomp(int l, const uint8_t *seq)
-	int mm_verbose_level(int v)
-	void mm_reset_timer()