minimap2 0.2.30.3 → 0.2.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a3bf89a18a50825f14454ce8683dd019377fc45e59a4d46eee617a55d0e64e8
-  data.tar.gz: c1dd61ced844c50b7aec1ba1f9da8d8b47ab3b94a1e2f4b0b4bcdd16169e4f0c
+  metadata.gz: b27519808e7302696fd897b42041bc6f6f11ac114bc9654a91c07c59f5284813
+  data.tar.gz: 8adb8dd6b933029ce21b66269750dc1017af4c5e3f292fb7f3da65c7bd25eae7
 SHA512:
-  metadata.gz: 198ae12116da51051dcac0665a85611a2d5bbe5df49ff854fff02c1f686f6c5fd7d40378876de81542d8ca9fe6fb8d71c0c59cde53497368ae4fc83b06a4c685
-  data.tar.gz: 1226cb572e95c805d3817bcaf5048fcc6a3bb217e7ac86b56f866b132c3ffe9ed5f8a1ba8e67b1bb798a1c2852e060f611229ccae9364b477a9863366717ce5c
+  metadata.gz: 30ac518def61ad07b388acb1a20dd4857cd7de124c3ca7eb942049834a6927763e2c31e8f9da12457eae786fad92a8153a28cb711f027124521721b7147eb4b0
+  data.tar.gz: 9cf1e73fb89b42a55630b049a9dd0a8612c68910f3b02227c2a19a2b0b57963497f7dce1e78dc0f13eafc69967f21eb2e5526808c4bda4d02f9f1bc6a57a57ef

data/README.md

@@ -4,7 +4,7 @@
 [![test](https://github.com/kojix2/ruby-minimap2/actions/workflows/ci.yml/badge.svg)](https://github.com/kojix2/ruby-minimap2/actions/workflows/ci.yml)
 [![Docs Latest](https://img.shields.io/badge/docs-latest-blue.svg)](https://kojix2.github.io/ruby-minimap2/)
 [![The MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
-[![DOI](https://zenodo.org/badge/325711305.svg)](https://zenodo.org/badge/latestdoi/325711305)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18489817.svg)](https://doi.org/10.5281/zenodo.18489817)
 [![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Fruby-minimap2%2Flines)](https://tokei.kojix2.net/github/kojix2/ruby-minimap2)
 
 :dna: [minimap2](https://github.com/lh3/minimap2) - the long-read mapper - for [Ruby](https://github.com/ruby/ruby)
@@ -43,7 +43,7 @@ require "minimap2"
 
 aligner = Minimap2::Aligner.new("ext/minimap2/test/MT-human.fa")
 seq     = aligner.seq("MT_human", 100, 200)
-hits    = aligner.align(seq)
+hits    = aligner.align(seq, cs: true, ds: true)
 pp hits
 ```
 
@@ -52,9 +52,10 @@ pp hits
   @blen=100,
   @cigar=[[100, 0]],
   @cigar_str="100M",
-  @cs="",
+  @cs=":100",
   @ctg="MT_human",
   @ctg_len=16569,
+  @ds=":100",
   @mapq=60,
   @md="",
   @mlen=100,
@@ -105,6 +106,7 @@ pp hits
       - cigar                   Returns CIGAR returned as an array of shape (n_cigar,2). The two numbers give the length and the operator of each CIGAR operation.
       - read_num                Returns read number that the alignment corresponds to; 1 for the first read and 2 for the second read.
       - cs                      Returns the cs tag.
+      - ds                      Returns the ds tag.
       - md                      Returns the MD tag as in the SAM format. It is an empty string unless the md argument is applied when calling Aligner#align.
       - cigar_str               Returns CIGAR string.
     * methods

data/ext/Rakefile

@@ -16,6 +16,9 @@ namespace :minimap2 do
   task :build do
     Dir.chdir(minimap2_dir) do
       # Add -fPIC option to Makefile
+      unless system("git", "--version", out: File::NULL, err: File::NULL)
+        abort "Git is required to build ruby-minimap2 from source. Install Git and ensure `git` is on PATH."
+      end
       sh "git apply ../minimap2.patch"
       sh "cp ../cmappy/cmappy.h ../cmappy/cmappy.c ."
       case RbConfig::CONFIG["host_cpu"]

data/ext/minimap2/Makefile

@@ -102,7 +102,7 @@ ksw2_exts2_neon.o:ksw2_exts2_sse.c ksw2.h kalloc.h
 # other non-file targets
 
 clean:
-		rm -fr gmon.out *.o a.out $(PROG) $(PROG_EXTRA) *~ *.a *.dSYM build dist mappy*.so mappy.c python/mappy.c mappy.egg*
+		rm -fr gmon.out *.o a.out $(PROG) $(PROG_EXTRA) *~ *.a *.dSYM build dist mappy*.so mappy.c python/mappy.c mappy.egg* .eggs
 
 depend:
 		(LC_ALL=C; export LC_ALL; makedepend -Y -- $(CFLAGS) $(CPPFLAGS) -- *.c)

data/ext/minimap2/NEWS.md

@@ -1,3 +1,36 @@
+Release 2.31-r1302 (19 May 2026)
+--------------------------------
+
+Notable changes to minimap2:
+
+ * Bugfix: supplementary and secondary alignments were occasionally flagged
+   incorrectly.
+
+ * Bugfix: Smith-Waterman alignment for inversion alignment led to an
+   out-of-bound access in rare cases.
+
+Changes to paftools.js:
+
+ * New feature: new `sim2bed` subcommand to get a BED file from simulated
+   reads.
+
+ * New feature: new `badread2fa` subcommand to format reads simulated by
+   the Badread simulator.
+
+Change to the python binding:
+
+ * New feature: mappy optionally writes the `ds` tag.
+
+ * Bugfix: a use-after-free error (#1345)
+
+The two bugs in minimap2 had existed for years. They were caught by Jeremy Wang
+at UNC when he ported minimap2 to Rust. Due to the two bug fixes, this version
+occasionally produces alignment different from the last version.
+
+(2.31: 19 May 2026, r1302)
+
+
+
 Release 2.30-r1287 (15 June 2025)
 ---------------------------------
 

data/ext/minimap2/README.md

@@ -3,6 +3,7 @@
 [![PyPI](https://img.shields.io/pypi/v/mappy.svg?style=flat)](https://pypi.python.org/pypi/mappy)
 [![Build Status](https://github.com/lh3/minimap2/actions/workflows/ci.yaml/badge.svg)](https://github.com/lh3/minimap2/actions)
 ## <a name="started"></a>Getting Started
+**ALERT:** `minimap2.com` is a [phishing site](https://github.com/lh3/minimap2/issues/1316). Please don't use anything from that website.
 ```sh
 git clone https://github.com/lh3/minimap2
 cd minimap2 && make
@@ -77,8 +78,8 @@ Detailed evaluations are available from the [minimap2 paper][doi] or the
 Minimap2 is optimized for x86-64 CPUs. You can acquire precompiled binaries from
 the [release page][release] with:
 ```sh
-curl -L https://github.com/lh3/minimap2/releases/download/v2.30/minimap2-2.30_x64-linux.tar.bz2 | tar -jxvf -
-./minimap2-2.30_x64-linux/minimap2
+curl -L https://github.com/lh3/minimap2/releases/download/v2.31/minimap2-2.31_x64-linux.tar.bz2 | tar -jxvf -
+./minimap2-2.31_x64-linux/minimap2
 ```
 If you want to compile from the source, you need to have a C compiler, GNU make
 and zlib development files installed. Then type `make` in the source code

data/ext/minimap2/cookbook.md

@@ -31,8 +31,8 @@ To acquire the data used in this cookbook and to install minimap2 and paftools,
 please follow the command lines below:
 ```sh
 # install minimap2 executables
-curl -L https://github.com/lh3/minimap2/releases/download/v2.30/minimap2-2.30_x64-linux.tar.bz2 | tar jxf -
-cp minimap2-2.30_x64-linux/{minimap2,k8,paftools.js} .  # copy executables
+curl -L https://github.com/lh3/minimap2/releases/download/v2.31/minimap2-2.31_x64-linux.tar.bz2 | tar jxf -
+cp minimap2-2.31_x64-linux/{minimap2,k8,paftools.js} .  # copy executables
 export PATH="$PATH:"`pwd`                               # put the current directory on PATH
 # download example datasets
 curl -L https://github.com/lh3/minimap2/releases/download/v2.10/cookbook-data.tgz | tar zxf -

data/ext/minimap2/format.c

@@ -361,24 +361,34 @@ static void write_cs_ds_or_MD(void *km, kstring_t *s, const mm_idx_t *mi, const
 	kfree(km, qseq); kfree(km, tseq); kfree(km, tmp);
 }
 
-int mm_gen_cs_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int no_iden, int is_qstrand)
+int mm_gen_cs_ds_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int is_ds, int no_iden, int is_qstrand)
 {
 	mm_bseq1_t t;
 	kstring_t str;
 	str.s = *buf, str.l = 0, str.m = *max_len;
 	t.l_seq = strlen(seq);
 	t.seq = (char*)seq;
-	write_cs_ds_or_MD(km, &str, mi, &t, r, no_iden, is_MD, 0, 0, is_qstrand);
+	write_cs_ds_or_MD(km, &str, mi, &t, r, no_iden, is_MD, is_ds, 0, is_qstrand);
 	*max_len = str.m;
 	*buf = str.s;
 	return str.l;
 }
 
+int mm_gen_cs_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int no_iden, int is_qstrand)
+{
+	return mm_gen_cs_ds_or_MD(km, buf, max_len, mi, r, seq, is_MD, 0, no_iden, is_qstrand);
+}
+
 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)
 {
 	return mm_gen_cs_or_MD(km, buf, max_len, mi, r, seq, 0, no_iden, 0);
 }
 
+int mm_gen_ds(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden)
+{
+	return mm_gen_cs_ds_or_MD(km, buf, max_len, mi, r, seq, 0, 1, no_iden, 0);
+}
+
 int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq)
 {
 	return mm_gen_cs_or_MD(km, buf, max_len, mi, r, seq, 1, 0, 0);

data/ext/minimap2/hit.c

@@ -256,19 +256,25 @@ void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int chec
 {
 	if (pri_ratio > 0.0f && *n_ > 0) {
 		int i, k, n = *n_, n_2nd = 0;
-		for (i = k = 0; i < n; ++i) {
+		uint8_t *keep = (uint8_t*)kmalloc(km, n);
+		for (i = 0; i < n; ++i) {
 			int p = r[i].parent;
+			keep[i] = 0;
 			if (p == i || r[i].inv) { // primary or inversion
-				r[k++] = r[i];
+				keep[i] = 1;
 			} else if ((r[i].score >= r[p].score * pri_ratio || r[i].score + min_diff >= r[p].score) && n_2nd < best_n) {
 				if (!(r[i].qs == r[p].qs && r[i].qe == r[p].qe && r[i].rid == r[p].rid && r[i].rs == r[p].rs && r[i].re == r[p].re)) // not identical hits
-					r[k++] = r[i], ++n_2nd;
-				else if (r[i].p) free(r[i].p);
+					keep[i] = 1, ++n_2nd;
 			} else if (check_strand && n_2nd < best_n && r[i].score > min_strand_sc && r[i].rev != r[p].rev) {
 				r[i].strand_retained = 1;
-				r[k++] = r[i], ++n_2nd;
-			} else if (r[i].p) free(r[i].p);
+				keep[i] = 1, ++n_2nd;
+			}
+		}
+		for (i = k = 0; i < n; ++i) {
+			if (keep[i]) r[k++] = r[i];
+			else if (r[i].p) free(r[i].p);
 		}
+		kfree(km, keep);
 		if (k != n) mm_sync_regs(km, k, r); // removing hits requires sync()
 		*n_ = k;
 	}
@@ -277,13 +283,18 @@ void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int chec
 int mm_filter_strand_retained(int n_regs, mm_reg1_t *r)
 {
 	int i, k;
-	for (i = k = 0; i < n_regs; ++i) {
+	uint8_t *keep = (uint8_t*)malloc(n_regs);
+	for (i = 0; i < n_regs; ++i) {
 		int p = r[i].parent;
-		if (!r[i].strand_retained || r[i].div < r[p].div * 5.0f || r[i].div < 0.01f) {
+		keep[i] = (!r[i].strand_retained || r[i].div < r[p].div * 5.0f || r[i].div < 0.01f);
+	}
+	for (i = k = 0; i < n_regs; ++i) {
+		if (keep[i]) {
 			if (k < i) r[k++] = r[i];
 			else ++k;
 		}
 	}
+	free(keep);
 	return k;
 }
 

data/ext/minimap2/ksw2_ll_sse.c

@@ -67,7 +67,7 @@ void *ksw_ll_qinit(void *km, int size, int qlen, const uint8_t *query, int m, co
 			const int8_t *ma = mat + a * m;
 			for (i = 0; i < slen; ++i)
 				for (k = i; k < nlen; k += slen) // p iterations
-					*t++ = (k >= qlen? 0 : ma[query[k]]) + q->shift;
+					*t++ = (k >= qlen? -1 : ma[query[k]]) + q->shift;
 		}
 	} else {
 		int16_t *t = (int16_t*)q->qp;
@@ -76,7 +76,7 @@ void *ksw_ll_qinit(void *km, int size, int qlen, const uint8_t *query, int m, co
 			const int8_t *ma = mat + a * m;
 			for (i = 0; i < slen; ++i)
 				for (k = i; k < nlen; k += slen) // p iterations
-					*t++ = (k >= qlen? 0 : ma[query[k]]);
+					*t++ = (k >= qlen? -1 : ma[query[k]]);
 		}
 	}
 	return q;

data/ext/minimap2/minimap.h

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <sys/types.h>
 
-#define MM_VERSION "2.30-r1287"
+#define MM_VERSION "2.31-r1302"
 
 #define MM_F_NO_DIAG       (0x001LL) // no exact diagonal hit
 #define MM_F_NO_DUAL       (0x002LL) // skip pairs where query name is lexicographically larger than target name
@@ -408,6 +408,7 @@ int mm_map_file_frag(const mm_idx_t *idx, int n_segs, const char **fn, const mm_
  * @return the length of cs
  */
 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_ds(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);
 
 // query sequence name and sequence in the minimap2 index

data/ext/minimap2/minimap2.1

@@ -1,4 +1,4 @@
-.TH minimap2 1 "15 June 2025" "minimap2-2.30 (r1287)" "Bioinformatics tools"
+.TH minimap2 1 "19 May 2026" "minimap2-2.31 (r1302)" "Bioinformatics tools"
 .SH NAME
 .PP
 minimap2 - mapping and alignment between collections of DNA sequences

data/ext/minimap2/misc/paftools.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env k8
 
-var paftools_version = '2.30-r1287';
+var paftools_version = '2.31-r1302';
 
 /*****************************
  ***** Library functions *****
@@ -1740,10 +1740,11 @@ function paf_gff2bed(args)
 
 function paf_sam2paf(args)
 {
-	var c, pri_only = false, long_cs = false, pri_pri_only = false;
-	while ((c = getopt(args, "pPL")) != null) {
+	var c, pri_only = false, long_cs = false, pri_pri_only = false, allow_unmapped = false;
+	while ((c = getopt(args, "pPUL")) != null) {
 		if (c == 'p') pri_only = true;
 		else if (c == 'P') pri_pri_only = pri_only = true;
+		else if (c == 'U') allow_unmapped = true;
 		else if (c == 'L') long_cs = true;
 	}
 	if (args.length == getopt.ind) {
@@ -1751,6 +1752,7 @@ function paf_sam2paf(args)
 		print("Options:");
 		print("  -p      convert primary or supplementary alignments only");
 		print("  -P      convert primary alignments only");
+		print("  -U      convert unmapped reads as well");
 		print("  -L      output the cs tag in the long form");
 		exit(1);
 	}
@@ -1775,7 +1777,15 @@ function paf_sam2paf(args)
 		var flag = parseInt(t[1]);
 		if (t[9] != '*' && t[10] != '*' && t[9].length != t[10].length)
 			throw Error("at line " + lineno + ": inconsistent SEQ and QUAL lengths - " + t[9].length + " != " + t[10].length);
-		if (t[2] == '*' || (flag&4) || t[5] == '*') continue;
+        if (t[2] == '*' || (flag&4) || t[5] == '*') {
+			if (allow_unmapped) {
+            // emit an unmapped PAF line instead of skipping
+            // fields: qname, qlen, qstart, qend, strand, tname, tlen, tstart, tend, n_match, aln_len, mapq
+            var qlen_val = (t[9] == '*' ? 0 : t[9].length);
+            print([t[0], qlen_val, 0, 0, '*', '*', 0, 0, 0, 0, 0, 0].join("\t"));
+			}
+            continue;
+        }
 		if (pri_only && (flag&0x100)) continue;
 		if (pri_pri_only && (flag&0x900)) continue;
 		var tlen = ctg_len[t[2]];
@@ -2338,6 +2348,41 @@ function paf_mason2fq(args)
 	buf2.destroy();
 }
 
+// convert Mason read names to BED
+function paf_sim2bed(args)
+{
+	if (args.length == 0) {
+		print("Usage: paftools.js sim2bed <sim.txt>");
+		exit(1);
+	}
+	var buf = new Bytes();
+	var file = new File(args[0]);
+	while (file.readline(buf) >= 0) {
+		var line = buf.toString();
+		var t = line.split("!");
+		if (t.length < 5) continue;
+		var chr = t[1], st, en, strand;
+		if (t[2].indexOf("_") >= 0) { // mason paired-end
+			var pos = t[2].split("_");
+			var end = t[3].split("_");
+			var m = /^(.)(.)\/([12])$/.exec(t[4]);
+			if (m == null) continue;
+			strand = m[3] == "1" ? m[1] : m[2];
+			var read_no = parseInt(m[3]) - 1;
+			st = parseInt(pos[read_no]);
+			en = parseInt(end[read_no]);
+		} else { // badread/pbsim long reads
+			st = parseInt(t[2]);
+			en = parseInt(t[3]);
+			strand = t[4];
+		}
+		if (st > en) { var tmp = st; st = en; en = tmp; }
+		print([chr, st, en, line, 0, strand].join("\t"));
+	}
+	file.close();
+	buf.destroy();
+}
+
 // convert pbsim MAF to FASTQ
 function paf_pbsim2fq(args)
 {
@@ -2395,6 +2440,53 @@ function paf_pbsim2fq(args)
 	buf2.destroy();
 }
 
+function paf_badread2fa(args)
+{
+	if (args.length < 2) {
+		print("Usage: paftools.js badread2fa <ref.fa.fai> <badread.fq>");
+		exit(1);
+	}
+
+	var len = {}, file, buf = new Bytes();
+	file = new File(args[0]);
+	while (file.readline(buf) >= 0) {
+		var t = buf.toString().split("\t");
+		len[t[0]] = parseInt(t[1]);
+	}
+	file.close();
+
+	var id = 0, n_discard = 0;
+	file = new File(args[1]);
+	while (file.readline(buf) >= 0) {
+		var line = buf.toString();
+		var m, tag = '', a = null, is_fq = line[0] == '@'? true : false;
+		if (!/\schimera\s/.test(line) && (m = /\s(\S+),([+-])strand,(\d+)-(\d+).*read_identity=([0-9\.]+)%/.exec(line)) != null) {
+			if (len[m[1]] == null) throw Error("failed to find the contig length of " + m[1]);
+			m[3] = parseInt(m[3]);
+			m[4] = parseInt(m[4]);
+			if (m[2] == '+')
+				a = [ "S" + (id+1), m[1], m[3], m[4], m[2] ];
+			else
+				a = [ "S" + (id+1), m[1], len[m[1]] - m[4], len[m[1]] - m[3], m[2] ];
+			tag = "ri:f:" + m[5];
+		}
+		file.readline(buf);
+		var seq = buf.toString();
+		if (is_fq) {
+			file.readline(buf);
+			file.readline(buf);
+		}
+		if (a != null) {
+			print(">" + a.join("!"), tag);
+			print(seq);
+		} else ++n_discard;
+		++id;
+	}
+	file.close();
+	buf.destroy();
+	warn("WARNING: discarded " + n_discard + " reads");
+}
+
 function paf_junceval(args)
 {
 	var c, l_fuzzy = 0, print_ovlp = false, print_err_only = false, first_only = false, chr_only = false, aa = false, is_bed = false;
@@ -3693,7 +3785,9 @@ function main(args)
 		print("  mapeval    evaluate mapping accuracy using mason2/PBSIM-simulated FASTQ");
 		print("  pafcmp     compare two PAF files");
 		print("  mason2fq   convert mason2-simulated SAM to FASTQ");
+	print("  sim2bed    convert mason2-simulated read names to BED");
 		print("  pbsim2fq   convert PBSIM-simulated MAF to FASTQ");
+		print("  badread2fa convert Baderead FASTQ to FASTA");
 		print("  junceval   evaluate splice junction consistency with known annotations");
 		print("  exoneval   evaluate exon-level consistency with known annotations");
 		print("  ov-eval    evaluate read overlap sensitivity using read-to-ref mapping");
@@ -3718,7 +3812,9 @@ function main(args)
 	else if (cmd == 'pafcmp') paf_pafcmp(args);
 	else if (cmd == 'bedcov') paf_bedcov(args);
 	else if (cmd == 'mason2fq') paf_mason2fq(args);
+	else if (cmd == 'sim2bed') paf_sim2bed(args);
 	else if (cmd == 'pbsim2fq') paf_pbsim2fq(args);
+	else if (cmd == 'badread2fa') paf_badread2fa(args);
 	else if (cmd == 'junceval') paf_junceval(args);
 	else if (cmd == 'exoneval') paf_exoneval(args);
 	else if (cmd == 'ov-eval') paf_ov_eval(args);

data/ext/minimap2/pe.c

@@ -8,7 +8,8 @@ void mm_select_sub_multi(void *km, float pri_ratio, float pri1, float pri2, int
 	if (pri_ratio > 0.0f && *n_ > 0) {
 		int i, k, n = *n_, n_2nd = 0;
 		int max_dist = n_segs == 2? qlens[0] + qlens[1] + max_gap_ref : 0;
-		for (i = k = 0; i < n; ++i) {
+		uint8_t *keep = (uint8_t*)kmalloc(km, n);
+		for (i = 0; i < n; ++i) {
 			int to_keep = 0;
 			if (r[i].parent == i) { // primary
 				to_keep = 1;
@@ -34,9 +35,13 @@ void mm_select_sub_multi(void *km, float pri_ratio, float pri1, float pri2, int
 			if (to_keep && r[i].parent != i) {
 				if (n_2nd++ >= best_n) to_keep = 0; // don't keep if there are too many secondary hits
 			}
-			if (to_keep) r[k++] = r[i];
+			keep[i] = to_keep;
+		}
+		for (i = k = 0; i < n; ++i) {
+			if (keep[i]) r[k++] = r[i];
 			else if (r[i].p) free(r[i].p);
 		}
+		kfree(km, keep);
 		if (k != n) mm_sync_regs(km, k, r); // removing hits requires sync()
 		*n_ = k;
 	}

data/ext/minimap2/python/cmappy.pxd

@@ -112,6 +112,7 @@ cdef extern from "minimap.h":
 	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_ds(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)
 
 #

data/ext/minimap2/python/mappy.pyx

@@ -3,7 +3,7 @@ from libc.stdlib cimport free
 cimport cmappy
 import sys
 
-__version__ = '2.30'
+__version__ = '2.31'
 
 cmappy.mm_reset_timer()
 
@@ -14,9 +14,9 @@ cdef class Alignment:
 	cdef int8_t _strand, _trans_strand
 	cdef uint8_t _mapq, _is_primary
 	cdef int _seg_id
-	cdef _ctg, _cigar, _cs, _MD # these are python objects
+	cdef _ctg, _cigar, _cs, _ds, _MD # these are python objects
 
-	def __cinit__(self, ctg, cl, cs, ce, strand, qs, qe, mapq, cigar, is_primary, mlen, blen, NM, trans_strand, seg_id, cs_str, MD_str):
+	def __cinit__(self, ctg, cl, cs, ce, strand, qs, qe, mapq, cigar, is_primary, mlen, blen, NM, trans_strand, seg_id, cs_str, ds_str, MD_str):
 		self._ctg = ctg if isinstance(ctg, str) else ctg.decode()
 		self._ctg_len, self._r_st, self._r_en = cl, cs, ce
 		self._strand, self._q_st, self._q_en = strand, qs, qe
@@ -27,6 +27,7 @@ cdef class Alignment:
 		self._trans_strand = trans_strand
 		self._seg_id = seg_id
 		self._cs = cs_str
+		self._ds = ds_str
 		self._MD = MD_str
 
 	@property
@@ -77,6 +78,9 @@ cdef class Alignment:
 	@property
 	def cs(self): return self._cs
 
+	@property
+	def ds(self): return self._ds
+
 	@property
 	def MD(self): return self._MD
 
@@ -96,6 +100,7 @@ cdef class Alignment:
 		a = [str(self._q_st), str(self._q_en), strand, self._ctg, str(self._ctg_len), str(self._r_st), str(self._r_en),
 			str(self._mlen), str(self._blen), str(self._mapq), tp, ts, "cg:Z:" + self.cigar_str]
 		if self._cs != "": a.append("cs:Z:" + self._cs)
+		if self._ds != "": a.append("ds:Z:" + self._ds)
 		if self._MD != "": a.append("MD:Z:" + self._MD)
 		return "\t".join(a)
 
@@ -165,7 +170,7 @@ cdef class Aligner:
 	def __bool__(self):
 		return (self._idx != NULL)
 
-	def map(self, seq, seq2=None, name=None, buf=None, cs=False, MD=False, max_frag_len=None, extra_flags=None):
+	def map(self, seq, seq2=None, name=None, buf=None, cs=False, ds=False, MD=False, max_frag_len=None, extra_flags=None):
 		cdef cmappy.mm_reg1_t *regs
 		cdef cmappy.mm_hitpy_t h
 		cdef ThreadBuffer b
@@ -184,7 +189,6 @@ cdef class Aligner:
 		if self._idx is NULL: return None
 		if buf is None: b = ThreadBuffer()
 		else: b = buf
-		km = cmappy.mm_tbuf_get_km(b._b)
 
 		_seq = seq if isinstance(seq, bytes) else seq.encode()
 		if name is not None:
@@ -206,19 +210,23 @@ cdef class Aligner:
 			i = 0
 			while i < n_regs:
 				cmappy.mm_reg2hitpy(self._idx, &regs[i], &h)
-				cigar, _cs, _MD = [], '', ''
+				cigar, _cs, _ds, _MD = [], '', '', ''
 				for k in range(h.n_cigar32): # convert the 32-bit CIGAR encoding to Python array
 					c = h.cigar32[k]
 					cigar.append([c>>4, c&0xf])
-				if cs or MD: # generate the cs and/or the MD tag, if requested
+				if cs or ds or MD: # generate the cs/ds and/or the MD tag, if requested
+					km = cmappy.mm_tbuf_get_km(b._b)
 					_cur_seq = _seq2 if h.seg_id > 0 and seq2 is not None else _seq
 					if cs:
 						l_cs_str = cmappy.mm_gen_cs(km, &cs_str, &m_cs_str, self._idx, &regs[i], _cur_seq, 1)
 						_cs = cs_str[:l_cs_str] if isinstance(cs_str, str) else cs_str[:l_cs_str].decode()
+					if ds:
+						l_cs_str = cmappy.mm_gen_ds(km, &cs_str, &m_cs_str, self._idx, &regs[i], _cur_seq, 1)
+						_ds = cs_str[:l_cs_str] if isinstance(cs_str, str) else cs_str[:l_cs_str].decode()
 					if MD:
 						l_cs_str = cmappy.mm_gen_MD(km, &cs_str, &m_cs_str, self._idx, &regs[i], _cur_seq)
 						_MD = cs_str[:l_cs_str] if isinstance(cs_str, str) else cs_str[:l_cs_str].decode()
-				yield Alignment(h.ctg, h.ctg_len, h.ctg_start, h.ctg_end, h.strand, h.qry_start, h.qry_end, h.mapq, cigar, h.is_primary, h.mlen, h.blen, h.NM, h.trans_strand, h.seg_id, _cs, _MD)
+				yield Alignment(h.ctg, h.ctg_len, h.ctg_start, h.ctg_end, h.strand, h.qry_start, h.qry_end, h.mapq, cigar, h.is_primary, h.mlen, h.blen, h.NM, h.trans_strand, h.seg_id, _cs, _ds, _MD)
 				cmappy.mm_free_reg1(&regs[i])
 				i += 1
 		finally:

data/ext/minimap2/python/minimap2.py

@@ -5,7 +5,7 @@ import getopt
 import mappy as mp
 
 def main(argv):
-	opts, args = getopt.getopt(argv[1:], "x:n:m:k:w:r:cM")
+	opts, args = getopt.getopt(argv[1:], "x:n:m:k:w:r:cdM")
 	if len(args) < 2:
 		print("Usage: minimap2.py [options] <ref.fa>|<ref.mmi> <query.fq>")
 		print("Options:")
@@ -16,11 +16,12 @@ def main(argv):
 		print("  -w INT      minimizer window length")
 		print("  -r INT      band width")
 		print("  -c          output the cs tag")
+		print("  -d          output the ds tag")
 		print("  -M          output the MD tag")
 		sys.exit(1)
 
 	preset = min_cnt = min_sc = k = w = bw = None
-	out_cs = out_MD = False
+	out_cs = out_ds = out_MD = False
 	for opt, arg in opts:
 		if opt == '-x': preset = arg
 		elif opt == '-n': min_cnt = int(arg)
@@ -29,12 +30,13 @@ def main(argv):
 		elif opt == '-k': k = int(arg)
 		elif opt == '-w': w = int(arg)
 		elif opt == '-c': out_cs = True
+		elif opt == '-d': out_ds = True
 		elif opt == '-M': out_MD = True
 
 	a = mp.Aligner(args[0], preset=preset, min_cnt=min_cnt, min_chain_score=min_sc, k=k, w=w, bw=bw)
 	if not a: raise Exception("ERROR: failed to load/build index file '{}'".format(args[0]))
 	for name, seq, qual in mp.fastx_read(args[1]): # read one sequence
-		for h in a.map(seq, cs=out_cs, MD=out_MD): # traverse hits
+		for h in a.map(seq, cs=out_cs, ds=out_ds, MD=out_MD): # traverse hits
 			print('{}\t{}\t{}'.format(name, len(seq), h))
 
 if __name__ == "__main__":

data/ext/minimap2/setup.py

@@ -23,7 +23,7 @@ def readme():
 
 setup(
 	name = 'mappy',
-	version = '2.30',
+	version = '2.31',
 	url = 'https://github.com/lh3/minimap2',
 	description = 'Minimap2 python binding',
 	long_description = readme(),

data/lib/minimap2/aligner.rb

@@ -160,6 +160,7 @@ module Minimap2
     # @param seq2 [String]
     # @param buf [FFI::TBuf]
     # @param cs [true, false]
+    # @param ds [true, false]
     # @param md [true, false]
     # @param max_frag_len [Integer]
     # @param extra_flags [Integer]
@@ -174,6 +175,7 @@ module Minimap2
       name: nil,
       buf: nil,
       cs: false,
+      ds: false,
       md: false,
       max_frag_len: nil,
       extra_flags: nil
@@ -223,7 +225,7 @@ module Minimap2
 
           cs_buf_ptr = nil
           m_cs_ptr = nil
-          if cs || md
+          if cs || ds || md
             cs_buf_ptr = ::FFI::MemoryPointer.new(:pointer)
             cs_buf_ptr.write_pointer(::FFI::Pointer::NULL)
             m_cs_ptr = ::FFI::MemoryPointer.new(:int)
@@ -239,8 +241,9 @@ module Minimap2
               cigar = c.map { |x| [x >> 4, x & 0xf] } # 32-bit CIGAR encoding -> Ruby array
 
               _cs = ""
+              _ds = ""
               _md = ""
-              if cs or md
+              if cs || ds || md
                 cur_seq = hit[:seg_id] > 0 && seq2 ? seq2 : seq
 
                 if cs
@@ -249,6 +252,12 @@ module Minimap2
                   _cs = cs_ptr.null? || l_cs_str <= 0 ? "" : cs_ptr.read_string(l_cs_str)
                 end
 
+                if ds
+                  l_cs_str = FFI.mm_gen_ds(km, cs_buf_ptr, m_cs_ptr, idx_part, regs[i], cur_seq, 1)
+                  cs_ptr = cs_buf_ptr.read_pointer
+                  _ds = cs_ptr.null? || l_cs_str <= 0 ? "" : cs_ptr.read_string(l_cs_str)
+                end
+
                 if md
                   l_cs_str = FFI.mm_gen_md(km, cs_buf_ptr, m_cs_ptr, idx_part, regs[i], cur_seq)
                   cs_ptr = cs_buf_ptr.read_pointer
@@ -256,7 +265,7 @@ module Minimap2
                 end
               end
 
-              alignments << Alignment.new(hit, cigar, _cs, _md)
+              alignments << Alignment.new(hit, cigar, _cs, _ds, _md)
 
               FFI.mm_free_reg1(regs[i])
               i += 1

data/lib/minimap2/alignment.rb

@@ -40,6 +40,8 @@ module Minimap2
   #     1 for the first read and 2 for the second read.
   # @!attribute cs
   #   @return [String] the cs tag.
+  # @!attribute ds
+  #   @return [String] the ds tag.
   # @!attribute md
   #   @return [String] the MD tag as in the SAM format.
   #     It is an empty string unless the md argument is applied when calling Aligner#align.
@@ -49,12 +51,12 @@ module Minimap2
   class Alignment
     def self.keys
       %i[ctg ctg_len r_st r_en strand trans_strand blen mlen nm primary
-         q_st q_en mapq cigar read_num cs md cigar_str]
+         q_st q_en mapq cigar read_num cs ds md cigar_str]
     end
 
     attr_reader(*keys)
 
-    def initialize(h, cigar, cs = nil, md = nil)
+    def initialize(h, cigar, cs = nil, ds = nil, md = nil)
       @ctg          = h[:ctg]
       @ctg_len      = h[:ctg_len]
       @r_st         = h[:ctg_start]
@@ -71,6 +73,7 @@ module Minimap2
       @cigar        = cigar
       @read_num     = h[:seg_id] + 1
       @cs           = cs
+      @ds           = ds
       @md           = md
 
       @cigar_str = cigar.map { |x| x[0].to_s + FFI::CIGAR_STR[x[1]] }.join
@@ -106,8 +109,9 @@ module Minimap2
            end
       a = [@q_st, @q_en, strand, @ctg, @ctg_len, @r_st, @r_en,
            @mlen, @blen, @mapq, tp, ts, "cg:Z:#{@cigar_str}"]
-      a << "cs:Z:#{@cs}" if @cs
-      a << "MD:Z:#{@md}" if @md
+      a << "cs:Z:#{@cs}" unless @cs.nil? || @cs.empty?
+      a << "ds:Z:#{@ds}" unless @ds.nil? || @ds.empty?
+      a << "MD:Z:#{@md}" unless @md.nil? || @md.empty?
       a.join("\t")
     end
   end

data/lib/minimap2/ffi/functions.rb

@@ -151,6 +151,12 @@ module Minimap2
       [:pointer, :pointer, :pointer, Idx.by_ref, Reg1.by_ref, :string, :int],
       :int
 
+    # int mm_gen_ds(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden);
+    attach_function \
+      :mm_gen_ds,
+      [:pointer, :pointer, :pointer, Idx.by_ref, Reg1.by_ref, :string, :int],
+      :int
+
     # int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq);
     attach_function \
       :mm_gen_md, :mm_gen_MD, # Avoid uppercase letters in method names.

data/lib/minimap2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Minimap2
-  VERSION = "0.2.30.3"
+  VERSION = "0.2.31.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.2.30.3
+  version: 0.2.31.0
 platform: ruby
 authors:
 - kojix2
@@ -167,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: minimap2
 test_files: []