Index
47 | 48 |
49 |
50 |
51 |
52 |
53 | \
726 |
\
768 | ';
769 |
770 | var replyTemplate = '\
771 | \
727 |
\
744 | \
728 | \
729 | 
\
730 | \
731 | \
732 | 
\
733 | \
734 |
\
735 | \
736 | \
737 | 
\
738 | \
739 | \
740 | 
\
741 | \
742 |
\
743 | \
745 |
\
766 | \
767 | \ 746 | <%username%>\ 747 | \ 748 | <%time.delta%>\ 749 |
\ 750 |<#text#>
\
751 | \ 752 | \ 753 | reply ▿\ 754 | proposal ▹\ 755 | \ 756 | \ 757 | \ 760 |
\ 761 |\ 762 | <#proposal_diff#>\ 763 |\ 764 |
41 |
81 |
89 |
90 |
91 |
92 |
93 |
94 |
--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
1 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
42 |
56 |
79 |
80 |
43 |
55 |
44 |
45 |
46 |
54 |
40 |
125 |
136 |
137 |
138 |
139 |
140 |
141 |
--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
1 | .. hts-python documentation master file, created by
2 | sphinx-quickstart on Wed Mar 1 09:40:03 2017.
3 | You can adapt this file completely to your liking, but it should at least
4 | contain the root `toctree` directive.
5 |
6 | hts-python
7 | ==========
8 |
9 | hts-python is a pythonic wrapper for `htslib
41 |
90 |
123 |
124 |
42 |
89 |
43 |
44 |
88 |
45 |
78 |
79 |
80 | hts-python¶
46 |hts-python is a pythonic wrapper for htslib using python cffi.
47 |A taste of hts-python...
48 |>>> import os.path as op
49 |
50 | >>> from hts import Bam
51 | >>> bam = Bam("hts/test/small.bam")
52 | >>> list(bam.header.seqs)
53 | ['chr2L', 'chr2R', 'chr3L', 'chr3R', 'chr4', 'chrX']
54 |
55 | >>> a = next(bam('chr2L:9000-11000'))
56 | >>> a
57 | Alignment('HWUSI-NAME:2:69:512:1017#0')
58 | >>> a.target, a.pos, a.strand
59 | ('chr2L', 9329, '-')
60 | >>> a.qlen, a.rlen
61 | (36, 36)
62 | >>> a.strand
63 | '-'
64 | >>> a.seq
65 | 'TACAAATCTTACGTAAACACTCCAAGCATGAATTCG'
66 | >>> a.qual[:10]
67 | [56, 63, 53, 62, 64, 62, 51, 44, 58, 59]
68 |
69 | >>> a.flag, a.flag_str
70 | (16, 'REVERSE')
71 |
72 | >>> a.cigar
73 | Cigar('36M')
74 |
75 | >>> str(a)[:40]
76 | 'HWUSI-NAME:2:69:512:1017#0\t16\tchr2L\t9330'
77 |
81 |
85 |
86 |
87 | See Also¶
82 |
83 |
84 |
48 |
91 |
99 |
100 |
101 |
102 |
103 |
104 |
--------------------------------------------------------------------------------
/docs/searchindex.js:
--------------------------------------------------------------------------------
1 | Search.setIndex({docnames:["index"],envversion:50,filenames:["index.rst"],objects:{},objnames:{},objtypes:{},terms:{"36m":0,"import":0,align:0,bam:0,cffi:0,chr2l:0,chr2r:0,chr3l:0,chr3r:0,chr4:0,chrx:0,cigar:0,flag:0,flag_str:0,from:0,header:0,htslib:0,hwusi:0,index:[],list:0,modul:[],name:0,next:0,page:[],path:0,pos:0,pybedtool:[],qlen:0,qual:0,revers:0,rlen:0,search:[],seq:0,small:0,stolen:[],str:0,strand:0,t16:0,t9330:0,tacaaatcttacgtaaacactccaagcatgaattcg:0,target:0,tast:0,tchr2l:0,test:0,thank:[],using:0,wrapper:0},titles:["hts-python"],titleterms:{also:0,document:[],hts:0,indic:[],python:0,see:0,tabl:[],welcom:[]}})
--------------------------------------------------------------------------------
/hts/__init__.py:
--------------------------------------------------------------------------------
1 | from .fai import Fai
2 | from .tbx import Tbx
3 | from .bam import Bam
4 | from .vcf import VCF
5 | from .fisher import fisher_exact_test
6 |
7 | __version__ = "0.0.3"
8 |
9 |
10 | def doctests():
11 | import doctest
12 | import hts.htsffi
13 | for name, mod in (("htsffi", hts.htsffi),
14 | ("fai", hts.fai),
15 | ("fisher", hts.fisher),
16 | ("vcf", hts.vcf),
17 | ("bam", hts.bam)):
18 |
19 | mod = getattr(hts, name)
20 | print("%s: %r" % (name, doctest.testmod(m=mod,
21 | optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)))
22 |
--------------------------------------------------------------------------------
/hts/bam.py:
--------------------------------------------------------------------------------
1 | from __future__ import print_function
2 | from .htsffi import libhts, ffi, _raise_if_null
3 | import atexit
4 | import os.path as op
5 | import sys
6 |
7 | class BamHeader(object):
8 | def __init__(self, h):
9 | self._h = h
10 |
11 | @property
12 | def seqs(self):
13 | for i in range(self._h.n_targets):
14 | yield ffi.string(self._h.target_name[i])
15 |
16 | class Cigar(object):
17 |
18 | """
19 | A cigar object usually created from `Alignment`.
20 |
21 | Takes the uin32_t * from bam_get_cigar()
22 |
23 | """
24 |
25 | ops = "MIDNSHP=XB"
26 |
27 | # cigar is the uint32_t * from bam_get_cigar()
28 | def __init__(self, cigar, n_cigar):
29 | self._c = cigar
30 | self.n_cigar = n_cigar
31 | def __str__(self):
32 | """Str."""
33 | cig, s = self._c, []
34 | for k in range(self.n_cigar):
35 | s.extend((str(libhts.bam_cigar_oplen(cig[k])),
36 | libhts.bam_cigar_opchr(cig[k])))
37 | return "".join(s)
38 |
39 | def __repr__(self):
40 | """repr."""
41 | return "Cigar('%s')" % str(self)
42 |
43 | class Alignment(object):
44 |
45 | """Alignment object; usually created by iterating over a `Bam` object."""
46 | __slots__ = ("_b", "_h")
47 |
48 | def __init__(self, bam1_t, bam_hdr_t):
49 | self._b = bam1_t
50 | self._h = bam_hdr_t
51 |
52 | def copy(self):
53 | """Create a copy of the alignment for modification or storage."""
54 | b = libhts.bam_dup1(self._b)
55 | atexit.register(libhts.bam_destroy1, b)
56 | return Alignment(b, self._h)
57 |
58 | @property
59 | def tags(self):
60 | """The auxillary tags from the alignment."""
61 | auxs = []
62 | l = libhts.bam_get_l_aux(self._b)
63 | if not l : return None
64 |
65 | s_aux_ptr = libhts.bam_get_aux(self._b)
66 | i = 0
67 | func = {'Z':libhts.bam_aux2Z, 'A': libhts.bam_aux2Z,
68 | 'i': libhts.bam_aux2i,
69 | 'I': libhts.bam_aux2i,
70 | 'c': libhts.bam_aux2i,
71 | 'C': libhts.bam_aux2i,
72 | 'f': libhts.bam_aux2f,
73 | 'F': libhts.bam_aux2f,
74 | 's': libhts.bam_aux2i,
75 | 'S': libhts.bam_aux2i}
76 |
77 | #print(str(self), file=sys.stderr)
78 | while i < l:
79 | key = "".join(chr(s) for s in s_aux_ptr[i:i + 2])
80 | ftype = chr(s_aux_ptr[i + 2])
81 | val = func[ftype](s_aux_ptr[i + 2:i + 2])
82 | if ftype in 'ZA':
83 | val = ffi.string(val)
84 | auxs.append((key, ftype, val))
85 | i += 3 + libhts.skip_aux(s_aux_ptr[i + 2:l])
86 |
87 | return auxs
88 |
89 | def adjust_overlap_quality(self, other):
90 | """
91 | Adjust base-quality of overlapping reads.
92 |
93 | For paired-end reads, we may not want to double-count both ends.
94 | This function will set (in-place), the base-quality of `other` to
95 | 0 and self to other + self for any overlapping bases.
96 | If bases are not equal then quality of self is set to 80% of its
97 | original value.
98 | """
99 | libhts.tweak_overlap_quality(self._b, other._b)
100 |
101 | @property
102 | def qname(self):
103 | """Read (query) name."""
104 | return ffi.string(libhts.bam_get_qname(self._b))
105 |
106 | @qname.setter
107 | def qname(self, name):
108 | """Set (query) name."""
109 | raise NotImplemented
110 | # need to check if proposed name is longer/shorter
111 | # than current and calloc self._b.data based on that!!!
112 | current_name = libhts.bam_get_qname(self._b)
113 |
114 | @property
115 | def rnext(self):
116 | tid = self._b.core.mtid
117 | if tid == -1:
118 | return None
119 | return ffi.string(self._h.target_name[tid])
120 |
121 | mate_chrom = rnext
122 |
123 | @property
124 | def pnext(self):
125 | return self._b.core.mpos
126 |
127 | mate_chrom = pnext
128 |
129 | @classmethod
130 | def from_sam_str(cls, sam_str, bam_hdr):
131 | s = ffi.new('kstring_t *', {'m': 0, 'l': 0, 's': ffi.NULL})
132 | libhts.kputsn(sam_str, len(sam_str) + 1, s)
133 |
134 | b = libhts.bam_init1()
135 | res = libhts.sam_parse1(s, bam_hdr, b)
136 | assert res <= 0, ("SAM parse error", res)
137 | h2 = libhts.bam_hdr_dup(bam_hdr)
138 | return Alignment(b, h2)
139 |
140 | @property
141 | def rname(self):
142 | """Chromosome or sequence aligned to."""
143 | tid = self._b.core.tid
144 | if tid == -1: # Read is unaligned, have no target
145 | return None
146 |
147 | return ffi.string(self._h.target_name[tid])
148 | target = rname
149 |
150 |
151 | @property
152 | def strand(self):
153 | """Strand of alignment."""
154 | return "-" if libhts.bam_is_rev(self._b) else "+"
155 |
156 | @property
157 | def base_qualities(self):
158 | """Base-qualities of query sequence."""
159 | q_ptr = libhts.bam_get_qual(self._b)
160 | has_qual = q_ptr[0] != 0xff
161 | if not has_qual: return None
162 | return [q_ptr[i] for i in range(self._b.core.l_qseq)]
163 |
164 | qual = base_qualities
165 |
166 | @property
167 | def pos(self):
168 | """Left-most position of alignment."""
169 | return self._b.core.pos
170 |
171 | @pos.setter
172 | def pos(self, value):
173 | """Set the position."""
174 | self._b.core.pos = value
175 |
176 | @property
177 | def isize(self):
178 | """Insert size of alignment if applicable."""
179 | return self._b.core.isize
180 | tlen = isize
181 |
182 | @property
183 | def mapping_quality(self):
184 | """Mapping quality of alignment."""
185 | return self._b.core.qual
186 |
187 | @mapping_quality.setter
188 | def mapping_quality(self, value):
189 | """Set the mapping quality to a new value."""
190 | self._b.core.qual = value
191 |
192 | mapq = mapping_quality
193 |
194 | @property
195 | def cigar(self):
196 | """Cigar object of alignment."""
197 | return Cigar(libhts.bam_get_cigar(self._b), self._b.core.n_cigar)
198 |
199 | @property
200 | def qlen(self):
201 | """Length of alignment by query."""
202 | return libhts.bam_cigar2qlen(self._b.core.n_cigar,
203 | libhts.bam_get_cigar(self._b))
204 |
205 | @property
206 | def rlen(self):
207 | """Length of alignment on reference."""
208 | return libhts.bam_cigar2rlen(self._b.core.n_cigar,
209 | libhts.bam_get_cigar(self._b))
210 |
211 | @property
212 | def seq(self):
213 | """Nucleotide sequence of read."""
214 | kstr = ffi.new('kstring_t *', {'m': 0, 'l': 0, 's': ffi.NULL})
215 | r = libhts.bam_get_read_seq(self._b, kstr)
216 | assert r == kstr.l, (r, kstr.l)
217 | return ffi.string(kstr.s)
218 |
219 | @property
220 | def flag_str(self):
221 | """Alignment flag as a string."""
222 | return ffi.string(libhts.bam_flag2str(self.flag))
223 |
224 | @property
225 | def flag(self):
226 | """Alignment flag."""
227 | return self._b.core.flag
228 |
229 | def __eq__(self, other):
230 | """test equality."""
231 | if self.qname != other.qname: return False
232 | if (self.pos, self.seq, self.mapq, self.qname) == \
233 | (other.pos, other.seq, other.mapq, other.qname):
234 | return True
235 | return False
236 |
237 | def __repr__(self):
238 | """repr of aln."""
239 | return "%s('%s')" % (self.__class__.__name__, self.qname)
240 |
241 | def __str__(self):
242 | """str of aln."""
243 | s = ffi.new("kstring_t *")
244 | l = libhts.sam_format1(self._h, self._b, s)
245 | return ffi.string(s.s, l)
246 |
247 | class Bam(object):
248 |
249 | r"""
250 | A BAM class with properties that call the C-API.
251 |
252 | Parameters
253 | ----------
254 |
255 | fname : string
256 | file name of bam
257 |
258 | mode : string
259 | mode for opening file r/w
260 |
261 | create_index: bool, string, optional
262 | if True, then force create index. If "auto", then only create index
263 | if it doesn't exist
264 |
265 | header: bam_hdr_t * or str
266 | ffi bam_hdr_t object for use when mode == "w"
267 | or a SAM header string.
268 |
269 | Examples
270 | --------
271 |
272 | >>> import os.path as op
273 | >>> bam = Bam("%s/test/small.bam" % op.dirname(__file__))
274 | >>> next(bam)
275 | Alignment('HWUSI-NAME:2:69:512:1017#0')
276 | >>> region_iter = bam('chr2L:9000-11000')
277 | >>> a = next(region_iter)
278 |
279 | # save copy for later test.
280 | >>> asav = a.copy()
281 |
282 | >>> list(bam.header.seqs)
283 | ['chr2L', 'chr2R', 'chr3L', 'chr3R', 'chr4', 'chrX']
284 |
285 |
286 | Query a specific Region
287 | >>> a
288 | Alignment('HWUSI-NAME:2:69:512:1017#0')
289 | >>> a.qname
290 | 'HWUSI-NAME:2:69:512:1017#0'
291 | >>> a.target
292 | 'chr2L'
293 |
294 | >>> a.cigar
295 | Cigar('36M')
296 | >>> a.qlen, a.rlen
297 | (36, 36)
298 |
299 | >>> a.strand
300 | '-'
301 |
302 | >>> a.seq
303 | 'TACAAATCTTACGTAAACACTCCAAGCATGAATTCG'
304 | >>> b = next(region_iter)
305 |
306 | >>> b.seq
307 | 'TGTAGAATGCAAAAATTACATTTGTGAGTATCATCA'
308 |
309 | # NOTE that a.seq has changed. this is because we updated the underlying
310 | # pointer and htslib assumes streaming stuff.
311 | >>> a.seq
312 | 'TGTAGAATGCAAAAATTACATTTGTGAGTATCATCA'
313 |
314 | # We can use the copy to avoid these problems:
315 | >>> asav.seq
316 | 'TACAAATCTTACGTAAACACTCCAAGCATGAATTCG'
317 | >>> a = asav
318 |
319 | # in the future, we may default to copy semantics or allow that to be specified
320 | # when creating a BAM.
321 |
322 | >>> a.flag, a.flag_str
323 | (16, 'REVERSE')
324 | >>> a.base_qualities[:10]
325 | [56, 63, 53, 62, 64, 62, 51, 44, 58, 59]
326 |
327 | >>> a.mapping_quality # or a.mapq
328 | 3
329 | >>> a.pos
330 | 9329
331 |
332 | >>> a.isize
333 | 0
334 |
335 | >>> str(a)
336 | 'HWUSI-NAME:2:69:512:1017#0\t16\tchr2L\t9330\t3\t36M\t*\t0\t0\tTACAAATCTTACGTAAACACTCCAAGCATGAATTCG\tY`V_a_TM[\\_V`abb`^^Q]QZaaaaa_aaaaaaa\tNM:i:0\tNH:i:2\tCC:Z:chrX\tCP:i:19096815'
337 |
338 | >>> a.tags
339 | [('NM', 'C', 0), ('NH', 'C', 2), ('CC', 'Z', 'chrX'), ('CP', 'I', 19096815)]
340 |
341 | >>> a.base_qualities[:10]
342 | [56, 63, 53, 62, 64, 62, 51, 44, 58, 59]
343 |
344 | # for paired end reads, we may want to avoid double-counting
345 | # the overlapping regions. We can use the samtools algorithm
346 | # to give a, the base-quality of a + b when the sequence is
347 | # the same or 0.8 * a when the seq is different. In either case,
348 | # the base-quality of b is set to 0.
349 | >>> b = a.copy()
350 |
351 | >>> a.adjust_overlap_quality(b)
352 | >>> a.base_qualities[:10]
353 | [112, 126, 106, 124, 128, 124, 102, 88, 116, 118]
354 |
355 | >>> b.base_qualities[:10]
356 | [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
357 |
358 | >>> all(bq == 0 for bq in b.base_qualities)
359 | True
360 |
361 | Writing.
362 |
363 | >>> out = Bam('out.bam', 'wb', header=a._h)
364 | >>> c = next(region_iter)
365 | >>> out.write(c, a, b); out.close()
366 |
367 | >>> cnew = next(Bam('out.bam'))
368 | >>> cnew.seq == c.seq
369 | True
370 |
371 | >>> (cnew == c, b.qname == a.qname)
372 | (True, True)
373 |
374 | we can also create a new writable bam with a fasta to create the bam header:
375 | >>> outf = Bam('outf.bam', mode='wb', fasta="hts/test/t2.fa")
376 |
377 | >>> outf.write(a); outf.close()
378 | >>> b = Bam('outf.bam')
379 | >>> b
380 | Bam('outf.bam', 'r')
381 |
382 | >>> next(b) == a
383 | True
384 |
385 |
386 | >>> a.pos
387 | 9329
388 | >>> a.pos += 1
389 | >>> a.pos
390 | 9330
391 |
392 | >>> assert a.mapq == 3
393 | >>> a.mapq += 55
394 | >>> assert a.mapping_quality == 58
395 |
396 | >>> a.rnext, a.pnext # no mate
397 | (None, -1)
398 |
399 | # string to object back to string.
400 | >>> s = str(a)
401 | >>> c = Alignment.from_sam_str(s, a._h)
402 | >>> str(c) == s
403 | True
404 |
405 | #>>> a.qname == "HELLO"
406 | #>>> assert "HELLO" in str(a)
407 | """
408 |
409 | def __init__(self, fname, mode="r", create_index="auto", header=None, fasta=None):
410 | self.fn, self.mode = fname, mode
411 |
412 | htf = self._htf = libhts.hts_open(fname, mode)
413 | _raise_if_null(htf, "Bam: bad file %s" % fname)
414 |
415 | if mode[0] == "r":
416 |
417 | idx = self._idx = libhts.sam_index_load(self._htf, fname)
418 | if (idx == ffi.NULL and create_index == "auto") or create_index is True:
419 | libhts.bam_index_build(fname, -1)
420 | idx = self._idx = libhts.sam_index_load(self._htf, fname)
421 | if idx == ffi.NULL:
422 | # no querying.
423 | print("NO querying", file=sys.stderr)
424 | pass
425 |
426 | self.header = BamHeader(libhts.sam_hdr_read(htf))
427 | b = self._b = libhts.bam_init1()
428 | atexit.register(libhts.bam_destroy1, b)
429 |
430 | else:
431 | assert mode[0] == "w" and (header or fasta)
432 | if hasattr(header, "_h"):
433 | header = header._h
434 | elif fasta:
435 | assert op.exists(fasta) # it's a fasta file.
436 | header_str = Bam.header_from_fasta(fasta)
437 | header = libhts.sam_hdr_parse(len(header_str), header_str)
438 | header.l_text = len(header_str)
439 | header.text = ffi.new("char[]", header_str)
440 |
441 | self.header = header
442 | libhts.sam_hdr_write(self._htf, self.header);
443 |
444 | def __repr__(self):
445 | return "Bam('%s', '%s')" % (self.fn, self.mode)
446 |
447 | def write(self, *alns):
448 | """
449 | Write alignments to the current file.
450 |
451 | Parameters
452 | ----------
453 | *alns: bam1_t *
454 |
455 | """
456 | for aln in alns:
457 | assert libhts.sam_write1(self._htf, self.header, aln._b) > 0, "error"
458 |
459 | @classmethod
460 | def header_from_fasta(self, fasta, sort_order='unknown'):
461 | """Create a sam header from a fasta file.
462 |
463 | >>> import os.path as op
464 | >>> fa = '%s/test/t.fa' % op.dirname(__file__)
465 | >>> print(Bam.header_from_fasta(fa)) #doctest: +NORMALIZE_WHITESPACE
466 | @HD VN:1.0 SO:unknown
467 | @SQ SN:chr1 LN:46
468 | """
469 | from .fai import Fai
470 | header = ["@HD\tVN:1.0\tSO:%s" % sort_order]
471 | for chrom, length in Fai(fasta):
472 | header.append("@SQ\tSN:%s\tLN:%i" % (chrom, length))
473 | return "\n".join(header) + "\n"
474 |
475 | def close(self):
476 | """Close the current file."""
477 | libhts.hts_close(self._htf)
478 |
479 | def flush(self):
480 | """Flush the current file."""
481 | libhts.bgzf_flush(self._htf.fp.bgzf)
482 |
483 | def __iter__(self):
484 | """Return self as an iterator of alignments."""
485 | return self
486 |
487 | def next(self):
488 | """Iterate over all alignments returning Alignment object."""
489 | if libhts.sam_read1(self._htf, self.header._h, self._b) >= 0:
490 | return Alignment(self._b, self.header._h)
491 | raise StopIteration()
492 |
493 | def __call__(self, region):
494 | """Perform a region query.
495 |
496 | Parameters
497 | ----------
498 | region : str
499 | region to query, e.g. chr1:1234-5678
500 | """
501 | qiter = libhts.sam_itr_querys(self._idx, self.header._h, region);
502 | try:
503 | slen = libhts.sam_itr_next(self._htf, qiter, self._b)
504 |
505 | while slen > 0:
506 | yield Alignment(self._b, self.header._h)
507 | slen = libhts.sam_itr_next(self._htf, qiter, self._b)
508 |
509 | finally:
510 | libhts.hts_itr_destroy(qiter)
511 |
--------------------------------------------------------------------------------
/hts/fai.py:
--------------------------------------------------------------------------------
1 | from .htsffi import libhts, ffi
2 | import os.path as op
3 | import atexit
4 |
5 | class Fai(object):
6 |
7 | """
8 | Random access to fasta files.
9 |
10 | uses 1-based starts for regions
11 |
12 | Arguments
13 | ---------
14 |
15 | fn: str
16 | fasta file path.
17 |
18 | Examples
19 | --------
20 |
21 | >>> f = Fai('%s/test/t.fa' % op.dirname(__file__))
22 | >>> f('chr1:1-10')
23 | 'AGAAAACCCC'
24 | >>> f.nseqs
25 | 1
26 | >>> 'chr1' in f
27 | True
28 | >>> 'chr2' in f
29 | False
30 |
31 | >>> for chrom, clen in f:
32 | ... print chrom, clen
33 | chr1 46
34 |
35 | >>> dict(f)
36 | {'chr1': 46}
37 | """
38 |
39 | def __init__(self, fn):
40 | """Create a new Fai object
41 |
42 | Examples
43 | --------
44 |
45 | >>> f = Fai('%s/test/t.fa' % op.dirname(__file__))
46 | """
47 | if fn.endswith(".fai"):
48 | fn = fn[:-4]
49 | assert op.exists(fn), (fn, "does not exist")
50 | if not op.exists("%s.fai" % fn):
51 | assert libhts.fai_build(fn) == 0
52 | self._fai = libhts.fai_load(fn)
53 | atexit.register(libhts.fai_destroy, self._fai)
54 | self.fn = fn
55 |
56 | def __call__(self, region):
57 | """Extract a region.
58 |
59 | Arguments
60 | ---------
61 |
62 | region: str
63 | """
64 | rlen = ffi.new("int *")
65 | seq = libhts.fai_fetch(self._fai, region, rlen)
66 | if rlen == -2:
67 | raise Exception("sequence not present")
68 | elif rlen == -1:
69 | raise Exception("error fetching sequence")
70 | return ffi.string(seq)
71 |
72 | @property
73 | def nseqs(self):
74 | """Count number of sequences in the fastq."""
75 | return libhts.faidx_nseq(self._fai)
76 |
77 | def __contains__(self, seq):
78 | """Test if a sequence name is in the fasta."""
79 | return bool(libhts.faidx_has_seq(self._fai, seq))
80 |
81 | def __iter__(self):
82 | """Generate names and lengths of the sequences."""
83 | with open(self.fn + ".fai") as fai:
84 | for toks in (l.rstrip("\r\n").split("\t") for l in fai):
85 | yield toks[0], int(toks[1])
86 |
--------------------------------------------------------------------------------
/hts/fisher.py:
--------------------------------------------------------------------------------
1 | from .htsffi import ffi, libhts
2 |
3 | def fisher_exact_test(n11, n12, n21, n22):
4 | """
5 | >>> ps = fisher_exact_test(20, 10, 10, 35)
6 | >>> ps['two_tail'], ps['right_tail'], ps['left_tail'] # doctest: +ELLIPSIS
7 | (0.00023..., 0.00014..., 0.9999...)
8 | """
9 | left, right = ffi.new("double *"), ffi.new("double *")
10 | two = ffi.new("double *")
11 | libhts.kt_fisher_exact(n11, n12, n21, n22, left, right, two)
12 | return dict(left_tail=left[0], right_tail=right[0], two_tail=two[0])
13 |
--------------------------------------------------------------------------------
/hts/hts_concat.h:
--------------------------------------------------------------------------------
1 | void *malloc(size_t size);
2 | void free(void *);
3 |
4 | char *strncpy(char *dst, char *src, size_t size);
5 | long int strtol (const char* str, char** endptr, int base);
6 |
7 |
8 | struct hFILE;
9 |
10 | //############################
11 | //# kstring
12 | //############################
13 |
14 | typedef struct __kstring_t {
15 | size_t l, m;
16 | char *s;
17 | } kstring_t;
18 |
19 | static inline char *ks_release(kstring_t *s);
20 | void kputsn(char *, int, kstring_t *);
21 |
22 |
23 | //##########################
24 | //# BGZF
25 | //##########################
26 | typedef struct __bgzidx_t bgzidx_t;
27 | typedef struct z_stream_s z_stream;
28 | struct BGZF;
29 | typedef struct BGZF BGZF;
30 | BGZF* bgzf_open(const char* path, const char *mode);
31 | int bgzf_close(BGZF *fp);
32 | BGZF* bgzf_hopen(struct hFILE *fp, const char *mode);
33 | int bgzf_flush(BGZF *fp);
34 |
35 |
36 | //###########################
37 | //# hts
38 | //###########################
39 | struct __hts_idx_t;
40 | typedef struct __hts_idx_t hts_idx_t;
41 |
42 | typedef struct {
43 | union {
44 | BGZF *bgzf;
45 | struct cram_fd *cram;
46 | struct hFILE *hfile;
47 | void *voidp;
48 | } fp;
49 | ...;
50 | } htsFile;
51 |
52 | htsFile *hts_open(const char *fn, const char *mode);
53 | int hts_close(htsFile *fp);
54 |
55 | int hts_getline(htsFile *fp, int delimiter, kstring_t *str);
56 | char **hts_readlines(const char *fn, int *_n);
57 | int hts_set_threads(htsFile *fp, int n);
58 | int hts_set_fai_filename(htsFile *fp, const char *fn_aux);
59 |
60 | typedef int hts_readrec_func(BGZF *fp, void *data, void *r, int *tid, int *beg, int *end);
61 | typedef const char *(*hts_id2name_f)(void*, int);
62 |
63 |
64 |
65 | struct _h;
66 | typedef struct _h hts_itr_t;
67 |
68 | hts_idx_t *hts_idx_init(int n, int fmt, uint64_t offset0, int min_shift, int n_lvls);
69 |
70 | void hts_idx_destroy(hts_idx_t *idx);
71 | int hts_idx_push(hts_idx_t *idx, int tid, int beg, int end, uint64_t offset, int is_mapped);
72 | void hts_idx_finish(hts_idx_t *idx, uint64_t final_offset);
73 |
74 | void hts_idx_save(const hts_idx_t *idx, const char *fn, int fmt);
75 | hts_idx_t *hts_idx_load(const char *fn, int fmt);
76 |
77 | uint8_t *hts_idx_get_meta(hts_idx_t *idx, int *l_meta);
78 | void hts_idx_set_meta(hts_idx_t *idx, int l_meta, uint8_t *meta, int is_copy);
79 |
80 | int hts_idx_get_stat(const hts_idx_t* idx, int tid, uint64_t* mapped, uint64_t* unmapped);
81 | uint64_t hts_idx_get_n_no_coor(const hts_idx_t* idx);
82 |
83 | const char *hts_parse_reg(const char *s, int *beg, int *end);
84 | hts_itr_t *hts_itr_query(const hts_idx_t *idx, int tid, int beg, int end, hts_readrec_func *readrec);
85 | void hts_itr_destroy(hts_itr_t *iter);
86 |
87 | int hts_itr_next(BGZF *fp, hts_itr_t *iter, void *r, void *data);
88 | const char **hts_idx_seqnames(const hts_idx_t *idx, int *n, hts_id2name_f getid, void *hdr);
89 |
90 |
91 | //###########################
92 | //# tbx
93 | //###########################
94 | typedef struct {
95 | int32_t preset;
96 | int32_t sc, bc, ec; // seq col., beg col. and end col.
97 | int32_t meta_char, line_skip;
98 | } tbx_conf_t;
99 |
100 | typedef struct {
101 | tbx_conf_t conf;
102 | hts_idx_t *idx;
103 | void *dict;
104 | } tbx_t;
105 |
106 |
107 | int tbx_index_build(const char *fn, int min_shift, const tbx_conf_t *conf);
108 | tbx_t *tbx_index_load(const char *fn);
109 | const char **tbx_seqnames(tbx_t *tbx, int *n); // free the array but not the values
110 | void tbx_destroy(tbx_t *tbx);
111 |
112 |
113 | hts_itr_t * tbx_itr_querys(tbx_t *tbx, char *);
114 |
115 | int tbx_itr_next(htsFile *fp, tbx_t *tbx, hts_itr_t *iter, void *data);
116 |
117 | //#####################################
118 | //# sam.h
119 | //#####################################
120 |
121 | typedef htsFile samFile;
122 |
123 | typedef struct {
124 | int32_t n_targets, ignore_sam_err;
125 | uint32_t l_text;
126 | uint32_t *target_len;
127 | int8_t *cigar_tab;
128 | char **target_name;
129 | char *text;
130 | void *sdict;
131 | } bam_hdr_t;
132 |
133 |
134 | typedef struct {
135 | int32_t tid;
136 | int32_t pos;
137 | uint16_t bin;
138 | uint8_t qual;
139 | uint8_t l_qname;
140 | uint16_t flag;
141 | uint8_t unused1;
142 | uint8_t l_extranul;
143 | uint32_t n_cigar;
144 | int32_t l_qseq;
145 | int32_t mtid;
146 | int32_t mpos;
147 | int32_t isize;
148 | } bam1_core_t;
149 |
150 | typedef struct {
151 | bam1_core_t core;
152 | int l_data, m_data;
153 | uint8_t *data;
154 | ...;
155 | } bam1_t;
156 |
157 |
158 |
159 | bam_hdr_t *sam_hdr_parse(int l_text, const char *text);
160 | bam_hdr_t *sam_hdr_read(samFile *fp);
161 | bam_hdr_t* bam_hdr_dup(const bam_hdr_t *h0);
162 | int bam_hdr_write(BGZF *fp, const bam_hdr_t *h);
163 | int sam_hdr_write(htsFile *fp, const bam_hdr_t *h);
164 | int sam_write1(htsFile *fp, const bam_hdr_t *h, const bam1_t *b);
165 |
166 |
167 |
168 | int sam_format1(const bam_hdr_t *h, const bam1_t *b, kstring_t *str);
169 | int sam_read1(samFile *fp, bam_hdr_t *h, bam1_t *b);
170 | int bam_read1(BGZF *fp, bam1_t *b);
171 |
172 | bam1_t *bam_init1();
173 | void bam_destroy1(bam1_t *b);
174 | int bam_is_rev(bam1_t *b);
175 | int bam_is_mrev(bam1_t *b);
176 | char *bam_get_qname(bam1_t *b);
177 | uint32_t *bam_get_cigar(bam1_t *b);
178 | uint8_t *bam_get_seq(bam1_t *b);
179 |
180 | uint8_t bam_seqi(uint8_t *c, int i);
181 |
182 | uint8_t *bam_get_qual(bam1_t *b);
183 |
184 | uint8_t *bam_get_aux(bam1_t *b);
185 | int bam_get_l_aux(bam1_t *b);
186 | uint8_t *bam_aux_get(const bam1_t *b, const char tag[2]);
187 | int32_t bam_aux2i(const uint8_t *s);
188 | float bam_aux2f(const uint8_t *s);
189 | char *bam_aux2Z(const uint8_t *s);
190 |
191 | bam1_t *bam_copy1(bam1_t *bdst, const bam1_t *bsrc);
192 | bam1_t *bam_dup1(const bam1_t *bsrc);
193 |
194 | int bam_cigar2qlen(int n_cigar, const uint32_t *cigar);
195 | int bam_cigar2rlen(int n_cigar, const uint32_t *cigar);
196 | int32_t bam_endpos(const bam1_t *b);
197 |
198 | int bam_str2flag(const char *str); /** returns negative value on error */
199 | char *bam_flag2str(int flag); /** The string must be freed by the user */
200 |
201 | int sam_parse1(kstring_t *s, bam_hdr_t *h, bam1_t *b);
202 |
203 |
204 |
205 | hts_idx_t * sam_index_load(samFile *in, char *); // load index
206 | int bam_index_build(const char *fn, int min_shift);
207 |
208 |
209 | hts_itr_t * sam_itr_querys(hts_idx_t*, bam_hdr_t *h, char * region);
210 |
211 | //int tbx_itr_next(htsFile *fp, tbx_t *tbx, hts_itr_t *iter, void *data);
212 | int sam_itr_next(htsFile *fp, hts_itr_t *iter, void *data);
213 |
214 | static const int BAM_CMATCH = 0;
215 | static const int BAM_CINS = 1;
216 | static const int BAM_CDEL = 2;
217 | static const int BAM_CREF_SKIP = 3;
218 | static const int BAM_CSOFT_CLIP = 4;
219 | static const int BAM_CHARD_CLIP = 5;
220 | static const int BAM_CPAD = 6;
221 | static const int BAM_CEQUAL = 7;
222 | static const int BAM_CDIFF = 8;
223 | static const int BAM_CBACK = 9;
224 |
225 | uint32_t bam_cigar_op(uint32_t cigar);
226 | char bam_cigar_opchr(uint32_t cigar);
227 | uint32_t bam_cigar_oplen(uint32_t cigar);
228 |
229 |
230 | typedef union {
231 | void *p;
232 | int64_t i;
233 | double f;
234 | } bam_pileup_cd;
235 |
236 |
237 | typedef struct {
238 | bam1_t *b;
239 | int32_t qpos;
240 | int indel, level;
241 | uint32_t is_del:1, is_head:1, is_tail:1, is_refskip:1, aux:28;
242 | bam_pileup_cd cd; // generic per-struct data, owned by caller.
243 | } bam_pileup1_t;
244 |
245 |
246 | typedef int (*bam_plp_auto_f)(void *data, bam1_t *b);
247 |
248 | struct __bam_plp_t;
249 | typedef struct __bam_plp_t *bam_plp_t;
250 |
251 | struct __bam_mplp_t;
252 | typedef struct __bam_mplp_t *bam_mplp_t;
253 |
254 | bam_plp_t bam_plp_init(bam_plp_auto_f func, void *data);
255 | void bam_plp_destroy(bam_plp_t iter);
256 | int bam_plp_push(bam_plp_t iter, const bam1_t *b);
257 | const bam_pileup1_t *bam_plp_next(bam_plp_t iter, int *_tid, int *_pos, int *_n_plp);
258 | const bam_pileup1_t *bam_plp_auto(bam_plp_t iter, int *_tid, int *_pos, int *_n_plp);
259 | void bam_plp_set_maxcnt(bam_plp_t iter, int maxcnt);
260 | void bam_plp_reset(bam_plp_t iter);
261 |
262 | bam_mplp_t bam_mplp_init(int n, bam_plp_auto_f func, void **data);
263 |
264 | void bam_mplp_init_overlaps(bam_mplp_t iter);
265 | void bam_mplp_destroy(bam_mplp_t iter);
266 | void bam_mplp_set_maxcnt(bam_mplp_t iter, int maxcnt);
267 | int bam_mplp_auto(bam_mplp_t iter, int *_tid, int *_pos, int *n_plp, const bam_pileup1_t **plp);
268 |
269 |
270 | //##############################################
271 | //# kfunc
272 | //##############################################
273 |
274 | double kt_fisher_exact(int n11, int n12, int n21, int n22, double *_left, double *_right, double *two);
275 |
276 | //##############################################
277 | //# faidx
278 | //##############################################
279 |
280 | struct __faidx_t;
281 | typedef struct __faidx_t faidx_t;
282 |
283 |
284 |
285 | void fai_destroy(faidx_t *fai);
286 | int fai_build(const char *fn);
287 |
288 | faidx_t *fai_load(const char *fn);
289 | // @param len Length of the region; -2 if seq not present, -1 general error
290 | char *fai_fetch(const faidx_t *fai, const char *reg, int *len);
291 | int faidx_nseq(const faidx_t *fai);
292 | char *faidx_fetch_seq(const faidx_t *fai, const char *c_name, int p_beg_i, int p_end_i, int *len);
293 | int faidx_has_seq(const faidx_t *fai, const char *seq);
294 |
295 | //##############################################
296 | //# vcf
297 | //##############################################
298 |
299 |
300 | /*
301 | typedef struct {
302 | int32_t rid; // CHROM
303 | int32_t pos; // POS
304 | int32_t rlen; // length of REF
305 | float qual; // QUAL
306 | uint32_t n_info:16, n_allele:16;
307 | uint32_t n_fmt:8, n_sample:24;
308 | kstring_t shared, indiv;
309 | bcf_dec_t d; // lazy evaluation: $d is not generated by bcf_read(), but by explicitly calling bcf_unpack()
310 | int max_unpack; // Set to BCF_UN_STR, BCF_UN_FLT, or BCF_UN_INFO to boost performance of vcf_parse when some of the fields won't be needed
311 | int unpacked; // remember what has been unpacked to allow calling bcf_unpack() repeatedly without redoing the work
312 | int unpack_size[3]; // the original block size of ID, REF+ALT and FILTER
313 | int errcode; // one of BCF_ERR_* codes
314 | } bcf1_t;
315 | */
316 |
317 |
318 | typedef struct {
319 | int type, n; // variant type and the number of bases affected, negative for deletions
320 | } variant_t;
321 |
322 | typedef struct {
323 | int id; // id: numeric tag id, the corresponding string is bcf_hdr_t::id[BCF_DT_ID][$id].key
324 | int n, size, type; // n: number of values per-sample; size: number of bytes per-sample; type: one of BCF_BT_* types
325 | uint8_t *p; // same as vptr and vptr_* in bcf_info_t below
326 | uint32_t p_len;
327 | uint32_t p_off:31, p_free:1;
328 | } bcf_fmt_t;
329 |
330 | typedef struct {
331 | int key; // key: numeric tag id, the corresponding string is bcf_hdr_t::id[BCF_DT_ID][$key].key
332 | int type, len; // type: one of BCF_BT_* types; len: vector length, 1 for scalars
333 | union {
334 | int32_t i; // integer value
335 | float f; // float value
336 | } v1; // only set if $len==1; for easier access
337 | uint8_t *vptr; // pointer to data array in bcf1_t->shared.s, excluding the size+type and tag id bytes
338 | uint32_t vptr_len; // length of the vptr block or, when set, of the vptr_mod block, excluding offset
339 | uint32_t vptr_off:31, // vptr offset, i.e., the size of the INFO key plus size+type bytes
340 | vptr_free:1; // indicates that vptr-vptr_off must be freed; set only when modified and the new
341 | // data block is bigger than the original
342 | } bcf_info_t;
343 |
344 |
345 | typedef struct {
346 | int32_t n[3];
347 | ...;
348 | } bcf_hdr_t;
349 |
350 |
351 | typedef struct {
352 | int m_fmt, m_info, m_id, m_als, m_allele, m_flt; // allocated size (high-water mark); do not change
353 | int n_flt; // Number of FILTER fields
354 | int *flt; // FILTER keys in the dictionary
355 | char *id, *als; // ID and REF+ALT block (\0-seperated)
356 | char **allele; // allele[0] is the REF (allele[] pointers to the als block); all null terminated
357 | bcf_info_t *info; // INFO
358 | bcf_fmt_t *fmt; // FORMAT and individual sample
359 | variant_t *var; // $var and $var_type set only when set_variant_types called
360 | int n_var, var_type;
361 | int shared_dirty; // if set, shared.s must be recreated on BCF output
362 | int indiv_dirty; // if set, indiv.s must be recreated on BCF output
363 | } bcf_dec_t;
364 |
365 | typedef struct {
366 | int32_t rid; // CHROM
367 | int32_t pos; // POS
368 | int32_t rlen; // length of REF
369 | float qual; // QUAL
370 | uint32_t n_info:16, n_allele:16;
371 | uint32_t n_fmt:8, n_sample:24;
372 | kstring_t shared, indiv;
373 | bcf_dec_t d; // lazy evaluation: $d is not generated by bcf_read(), but by explicitly calling bcf_unpack()
374 | int max_unpack; // Set to BCF_UN_STR, BCF_UN_FLT, or BCF_UN_INFO to boost performance of vcf_parse when some of the fields won't be needed
375 | int unpacked; // remember what has been unpacked to allow calling bcf_unpack() repeatedly without redoing the work
376 | int unpack_size[3]; // the original block size of ID, REF+ALT and FILTER
377 | int errcode; // one of BCF_ERR_* codes
378 | } bcf1_t;
379 |
380 |
381 | bcf1_t *bcf_init(void);
382 |
383 |
384 |
385 | bcf_hdr_t *bcf_hdr_read(htsFile *fp);
386 | int bcf_hdr_set_samples(bcf_hdr_t *hdr, const char *samples, int is_file);
387 |
388 | int bcf_read(htsFile *fp, const bcf_hdr_t *h, bcf1_t *v);
389 |
390 | static inline const char *bcf_hdr_id2name(const bcf_hdr_t *hdr, int rid);
391 |
392 | int bcf_unpack(bcf1_t *b, int which);
393 |
394 | static const int BCF_DT_SAMPLE = 2;
395 |
396 | int bcf_get_genotypes(const bcf_hdr_t *hdr, bcf1_t *line, int **dst, int *ndst);
397 | int bcf_get_format_values(const bcf_hdr_t *hdr, bcf1_t *line, const char *tag, void **dst, int *ndst, int type);
398 | //typedef htsFile vcfFile;
399 |
400 |
401 |
402 |
403 |
404 | //##############################################
405 | //# hts_extra
406 | //##############################################
407 | //int bam_get_read_seq(bam1_t *b, kstring_t *str);
408 |
--------------------------------------------------------------------------------
/hts/hts_extra.c:
--------------------------------------------------------------------------------
1 | #include "htslib/sam.h"
2 | #include "htslib/vcf.h"
3 | #include "htslib/kstring.h"
4 |
5 |
6 | // the htslib api only provides bam_seqi to get one base at a time.
7 | // to avoid having to call that, e.g. 100 times to get the sequence for
8 | // a 100 base read, we implement this.
9 | int bam_get_read_seq(bam1_t *b, kstring_t * str){
10 | int i = 0;
11 | str->l = 0;
12 | uint8_t *s = bam_get_seq(b);
13 | for (; i < b->core.l_qseq; ++i) kputc("=ACMGRSVTWYHKDBN"[bam_seqi(s, i)], str);
14 | return i;
15 | }
16 |
17 | int as_gts(int *gts, int num_samples) {
18 | int j = 0, i;
19 | for (i = 0; i < 2 * num_samples; i += 2){
20 | if (bcf_gt_is_missing(gts[i]) && bcf_gt_is_missing(gts[i+1])){
21 | gts[j++] = 2; // unknown
22 | continue;
23 | }
24 | int a = bcf_gt_allele(gts[i]);
25 | int b = bcf_gt_allele(gts[i+1]);
26 |
27 | if((a == 0) && (b == 0)) {
28 | gts[j] = 0; // HOM_REF
29 | }
30 | else if((a == 1) && (b == 1)) {
31 | gts[j] = 3; // HOM_ALT
32 | }
33 | else if((a != b)) {
34 | gts[j] = 1; // HET
35 | } else {
36 | gts[j] = 2; // unknown
37 | }
38 | j++;
39 | }
40 | // free the latter part of the array that we don't need.
41 | //free((void *)(&(gts[j])));
42 | return j;
43 | }
44 |
45 |
46 | static inline int cigar_iref2iseq_set(uint32_t **cigar, uint32_t *cigar_max, int *icig, int *iseq, int *iref)
47 | {
48 | int pos = *iref;
49 | if ( pos < 0 ) return -1;
50 | *icig = 0;
51 | *iseq = 0;
52 | *iref = 0;
53 | while ( *cigar
49 |
79 |
89 |
90 |
50 |
78 |
51 |
52 |
77 | Search
53 |
54 |
55 |
60 | 56 | Please activate JavaScript to enable the search 57 | functionality. 58 |
59 |61 | From here you can search these documents. Enter your search 62 | words into the box below and click "search". Note that the search 63 | function will automatically search for all of the words. Pages 64 | containing fewer words won't appear in the result list. 65 |
66 | 71 | 72 |
73 |
74 |
75 |
76 |
\ 689 | Sort by:\ 690 | best rated\ 691 | newest\ 692 | oldest\ 693 |
\ 694 |\ 698 |
Add a comment\ 700 | (markup):
\ 701 |``code``, \ 704 | code blocks:::and an indented block after blank line