HTSeq 2.1.2__cp313-cp313-macosx_10_15_x86_64.whl

HTSeq/__init__.py

@@ -0,0 +1,1249 @@
+"""HTSeq is a package to process high-throughput sequencing data.
+
+See htseq.readthedocs.io/en/master/index.html for documentation.
+"""
+
+import importlib.metadata
+import itertools
+import warnings
+import os
+import shlex
+import sys
+import re
+
+import HTSeq
+from HTSeq._HTSeq import *
+from HTSeq.utils import FileOrSequence
+from HTSeq.features import *
+from HTSeq.StretchVector import StretchVector
+
+
+#########################
+# Version
+#########################
+__version__ = importlib.metadata.version("HTSeq")
+
+
+#########################
+# GenomicArray
+#########################
+
+
+def read_chrom_lens(filename, delimiter="\t"):
+    return dict(
+        (
+            (chrom, int(len))
+            for chrom, len in csv.reader(open(filename), delimiter=delimiter)
+        )
+    )
+
+
+#########################
+# Sequence readers
+#########################
+
+_re_fasta_header_line = re.compile(r">\s*(\S+)\s*(.*)")
+
+
+class FastaReader(FileOrSequence):
+    """A Fasta_Reader is associated with a FASTA file or an open connection
+    to a file-like object with content in FASTA format.
+    It can generate an iterator over the sequences.
+    """
+
+    def __init__(self, file_, raw_iterator=False):
+        FileOrSequence.__init__(self, file_)
+        self.raw_iterator = raw_iterator
+
+    def __iter__(self):
+        seq = None
+        name = None
+        descr = None
+        for line in FileOrSequence.__iter__(self):
+            if line.startswith(">"):
+                if seq:
+                    if self.raw_iterator:
+                        s = (seq, name, descr)
+                    else:
+                        s = Sequence(seq.encode(), name)
+                        s.descr = descr
+                    yield s
+                mo = _re_fasta_header_line.match(line)
+                name = mo.group(1)
+                descr = mo.group(2)
+                seq = ""
+            else:
+                assert seq is not None, "FASTA file does not start with '>'."
+                seq += line[:-1]
+        if seq is not None:
+            if self.raw_iterator:
+                s = (seq, name, descr)
+            else:
+                s = Sequence(seq.encode(), name)
+                s.descr = descr
+            yield s
+
+    def get_sequence_lengths(self):
+        seqname = None
+        length = 0
+        seqlengths = {}
+        for line in FileOrSequence.__iter__(self):
+            if line.startswith(">"):
+                if seqname is not None:
+                    seqlengths[seqname] = length
+                mo = _re_fasta_header_line.match(line)
+                seqname = mo.group(1)
+                length = 0
+            else:
+                assert seqname is not None, "FASTA file does not start with '>'."
+                length += len(line.rstrip())
+        if seqname is not None:
+            seqlengths[seqname] = length
+        return seqlengths
+
+    @staticmethod
+    def _import_pysam():
+        global pysam
+        try:
+            import pysam
+        except ImportError:
+            sys.stderr.write(
+                "Please install the 'pysam' package to be able to use the Fasta indexing functionality."
+            )
+            raise
+
+    def build_index(self, force=False):
+        self._import_pysam()
+        if not isinstance(self.fos, str):
+            raise TypeError(
+                "This function only works with FastaReader objects "
+                + "connected to a fasta file via file name"
+            )
+        index_filename = self.fos + ".fai"
+        if os.access(index_filename, os.R_OK):
+            if (not force) and os.stat(self.filename_or_sequence).st_mtime <= os.stat(
+                index_filename
+            ).st_mtime:
+                # index is up to date
+                return
+        pysam.faidx(self.fos)
+        if not os.access(index_filename, os.R_OK):
+            raise SystemError("Building of Fasta index failed due to unknown error.")
+
+    def __getitem__(self, iv):
+        if not isinstance(iv, GenomicInterval):
+            raise TypeError("GenomicInterval expected as key.")
+        if not isinstance(self.fos, str):
+            raise TypeError(
+                "This function only works with FastaReader objects "
+                + "connected to a fasta file via file name"
+            )
+        self._import_pysam()
+        fasta = pysam.faidx(self.fos, "%s:%d-%d" % (iv.chrom, iv.start, iv.end - 1))
+        ans = list(FastaReader(fasta))
+        assert len(ans) == 1
+        ans[0].name = str(iv)
+        if iv.strand != "-":
+            return ans[0]
+        else:
+            return ans[0].get_reverse_complement()
+
+
+class FastqReader(FileOrSequence):
+    """A Fastq object is associated with a FASTQ self.file. When an iterator
+    is requested from the object, the FASTQ file is read.
+
+    qual_scale is one of "phred", "solexa", "solexa-old".
+    """
+
+    def __init__(self, file_, qual_scale="phred", raw_iterator=False):
+        FileOrSequence.__init__(self, file_)
+        self.qual_scale = qual_scale
+        if qual_scale not in ("phred", "solexa", "solexa-old"):
+            raise ValueError("Illegal quality scale.")
+        self.raw_iterator = raw_iterator
+
+    def __iter__(self):
+        fin = FileOrSequence.__iter__(self)
+        il = 0
+        id1 = None
+        id2 = None
+        seq = None
+        qual = None
+        for line in fin:
+            if il == 0:
+                id1 = line
+                il += 1
+                continue
+            elif il == 1:
+                seq = line
+                il += 1
+                continue
+            elif il == 2:
+                id2 = line
+                il += 1
+                continue
+
+            qual = line
+            il = 0
+
+            if qual == "":
+                if id1 != "":
+                    warnings.warn(
+                        "Number of lines in FASTQ file is not "
+                        "a multiple of 4. Discarding the last, "
+                        "incomplete record"
+                    )
+                break
+
+            if not qual.endswith("\n"):
+                qual += "\n"
+            if not id1.startswith("@"):
+                raise ValueError(
+                    "Primary ID line in FASTQ file does "
+                    "not start with '@'. Either this is not FASTQ data or the "
+                    "parser got out of sync."
+                )
+            if not id2.startswith("+"):
+                raise ValueError(
+                    "Secondary ID line in FASTQ file does"
+                    "not start with '+'. Maybe got out of sync."
+                )
+            if len(id2) > 2 and id1[1:] != id2[1:]:
+                raise ValueError("Primary and secondary ID line in FASTQdisagree.")
+
+            if self.raw_iterator:
+                s = (seq[:-1], id1[1:-1], qual[:-1], self.qual_scale)
+            else:
+                s = SequenceWithQualities(
+                    seq[:-1].encode(), id1[1:-1], qual[:-1].encode(), self.qual_scale
+                )
+            yield s
+
+
+class BowtieReader(FileOrSequence):
+    """A BowtieFile object is associated with a Bowtie output file that
+    contains short read alignments. It can generate an iterator of Alignment
+    objects."""
+
+    def __iter__(self):
+        for line in FileOrSequence.__iter__(self):
+            try:
+                algnt = BowtieAlignment(line)
+            except ValueError:
+                if line.startswith("Reported "):
+                    continue
+                warnings.warn(
+                    "BowtieReader: Ignoring the following line, which could "
+                    "not be parsed:\n%s\n" % line,
+                    RuntimeWarning,
+                )
+            yield algnt
+
+
+def bundle_multiple_alignments(sequence_of_alignments):
+    """Some alignment programs, e.g., Bowtie, can output multiple alignments,
+    i.e., the same read is reported consecutively with different alignments.
+    This function takes an iterator over alignments and bundles consecutive
+    alignments regarding the same read to a list of Alignment objects and
+    returns an iterator over these.
+    """
+    alignment_iter = iter(sequence_of_alignments)
+    algnt = next(alignment_iter)
+    ma = [algnt]
+    for algnt in alignment_iter:
+        if algnt.read.name != ma[0].read.name:
+            yield ma
+            ma = [algnt]
+        else:
+            ma.append(algnt)
+    yield ma
+
+
+class SolexaExportAlignment(Alignment):
+    """Iterating over SolexaExportReader objects will yield SoelxaExportRecord
+    objects. These have four fields:
+       read          - a SequenceWithQualities object
+       aligned       - a boolean, indicating whether the object was aligned
+       iv            - a GenomicInterval giving the alignment (or None, if not aligned)
+       passed_filter - a boolean, indicating whether the object passed the filter
+       nomatch_code  - a code indicating why no match was found (or None, if the
+         read was aligned)
+
+    As long as 'aligned' is True, a SolexaExportRecord can be treated as an
+    Alignment object.
+    """
+
+    def __init__(self):
+        # Data is filled in by SolexaExportRecord
+        pass
+
+    def __repr__(self):
+        if self.aligned:
+            return "< %s object: Read '%s', aligned to %s >" % (
+                self.__class__.__name__,
+                self.read.name,
+                self.iv,
+            )
+        else:
+            return "< %s object: Non-aligned read '%s' >" % (
+                self.__class__.__name__,
+                self.read.name,
+            )
+
+
+class SolexaExportReader(FileOrSequence):
+    """Parser for *_export.txt files from the SolexaPipeline software.
+
+    Iterating over a SolexaExportReader yields SolexaExportRecord objects.
+    """
+
+    def __init__(self, filename_or_sequence, solexa_old=False):
+        FileOrSequence.__init__(self, filename_or_sequence)
+        if solexa_old:
+            self.qualscale = "solexa-old"
+        else:
+            self.qualscale = "solexa"
+
+    @classmethod
+    def parse_line_bare(dummy, line):
+        if line[-1] == "\n":
+            line = line[:-1]
+        res = {}
+        (
+            res["machine"],
+            res["run_number"],
+            res["lane"],
+            res["tile"],
+            res["x_coord"],
+            res["y_coord"],
+            res["index_string"],
+            res["read_nbr"],
+            res["read_seq"],
+            res["qual_str"],
+            res["chrom"],
+            res["contig"],
+            res["pos"],
+            res["strand"],
+            res["match_descr"],
+            res["single_read_algnt_score"],
+            res["paired_read_algnt_score"],
+            res["partner_chrom"],
+            res["partner_contig"],
+            res["partner_offset"],
+            res["partner_strand"],
+            res["passed_filtering"],
+        ) = line.split("\t")
+        return res
+
+    def __iter__(self):
+        for line in FileOrSequence.__iter__(self):
+            record = SolexaExportAlignment()
+            fields = SolexaExportReader.parse_line_bare(line)
+            if fields["read_nbr"] != "1":
+                warnings.warn(
+                    "Paired-end read encountered. PE is so far supported only "
+                    "for SAM files, not yet for SolexaExport. All PE-related "
+                    "fields are ignored."
+                )
+            record.read = SequenceWithQualities(
+                fields["read_seq"],
+                "%s:%s:%s:%s:%s#0"
+                % (
+                    fields["machine"],
+                    fields["lane"],
+                    fields["tile"],
+                    fields["x_coord"],
+                    fields["y_coord"],
+                ),
+                fields["qual_str"],
+                self.qualscale,
+            )
+            if fields["passed_filtering"] == "Y":
+                record.passed_filter = True
+            elif fields["passed_filtering"] == "N":
+                record.passed_filter = False
+            else:
+                raise ValueError(
+                    "Illegal 'passed filter' value in Solexa export data: '%s'."
+                    % fields["passed_filtering"]
+                )
+            record.index_string = fields["index_string"]
+            if fields["pos"] == "":
+                record.iv = None
+                record.nomatch_code = fields["chrom"]
+            else:
+                if fields["strand"] == "F":
+                    strand = "+"
+                elif fields["strand"] == "R":
+                    strand = "-"
+                else:
+                    raise ValueError("Illegal strand value in Solexa export data.")
+                start = int(fields["pos"])
+                chrom = fields["chrom"]
+                if fields["chrom"] == "":
+                    chrom = fields["contig"]
+                record.iv = GenomicInterval(
+                    chrom, start, start + len(fields["read_seq"]), strand
+                )
+            yield record
+
+
+class GenomicArrayOfSets(GenomicArray):
+    """A GenomicArrayOfSets is a specialization of GenomicArray that allows to store
+    sets of objects. On construction, the step vectors are initialized with empty sets.
+    By using the 'add_value' method, objects can be added to intervals. If an object
+    is already present in the set(s) at this interval, an the new object is added to
+    the present set, and the set is split if necessary.
+    """
+
+    def __init__(self, chroms, stranded=True, storage="step", memmap_dir=""):
+        GenomicArray.__init__(self, chroms, stranded, "O", storage, memmap_dir)
+
+    def add_chrom(self, chrom, length=sys.maxsize, start_index=0):
+        GenomicArray.add_chrom(self, chrom, length, start_index)
+        for cv in list(self.chrom_vectors[chrom].values()):
+            cv[:] = set()
+            cv.is_vector_of_sets = True
+
+
+###########################
+# paired-end handling
+###########################
+
+
+def pair_SAM_alignments(alignments, bundle=False, primary_only=False):
+    """Iterate over SAM aligments, name-sorted paired-end
+
+    Args:
+        alignments (iterator of SAM/BAM alignments): the alignments to wrap
+        bundle (bool): if True, bundle all alignments from one read pair into a
+            single yield. If False (default), each pair of alignments is
+            yielded separately.
+        primary_only (bool): for each read, consider only the primary line
+            (SAM flag 0x900 = 0). The SAM specification requires one and only
+            one of those for each read.
+
+    Yields:
+        2-tuples with each pair of alignments or, if bundle==True, each bundled
+        list of alignments.
+    """
+
+    mate_missing_count = [0]
+
+    def process_list(almnt_list):
+        """Transform a list of alignment with the same read name into pairs
+
+        Args:
+            almnt_list (list): alignments to process
+
+        Yields:
+            each pair of alignments.
+
+        This function is needed because each line of a BAM file is not a read
+        but an alignment. For uniquely mapped and unmapped reads, those two are
+        the same. For multimapped reads, however, there can be more than one
+        alignment for each read. Also, it is normal for a mapper to uniquely
+        map one read and multimap its mate.
+
+        This function goes down the list of alignments for a given read name
+        and tries to find the first mate. So if read 1 is uniquely mapped but
+        read 2 is mapped 4 times, only (read 1, read 2 - first occurrence) will
+        yield; the other 3 alignments of read 2 are ignored.
+        """
+
+        while len(almnt_list) > 0:
+            a1 = almnt_list.pop(0)
+            # Find its mate
+            for a2 in almnt_list:
+                if a1.pe_which == a2.pe_which:
+                    continue
+                if a1.aligned != a2.mate_aligned or a1.mate_aligned != a2.aligned:
+                    continue
+                if not (a1.aligned and a2.aligned):
+                    break
+                if (
+                    a1.iv.chrom == a2.mate_start.chrom
+                    and a1.iv.start == a2.mate_start.pos
+                    and a2.iv.chrom == a1.mate_start.chrom
+                    and a2.iv.start == a1.mate_start.pos
+                ):
+                    break
+            else:
+                if a1.mate_aligned:
+                    mate_missing_count[0] += 1
+                    if mate_missing_count[0] == 1:
+                        warnings.warn(
+                            "Read "
+                            + a1.read.name
+                            + " claims to have an aligned mate "
+                            + "which could not be found in an adjacent line."
+                        )
+                a2 = None
+            if a2 is not None:
+                almnt_list.remove(a2)
+            if a1.pe_which == "first":
+                yield (a1, a2)
+            else:
+                assert a1.pe_which == "second"
+                yield (a2, a1)
+
+    almnt_list = []
+    current_name = None
+    for almnt in alignments:
+        if not almnt.paired_end:
+            raise ValueError(
+                "'pair_alignments' needs a sequence of paired-end alignments"
+            )
+        if almnt.pe_which == "unknown":
+            raise ValueError("Paired-end read found with 'unknown' 'pe_which' status.")
+
+        # FIXME: almnt.not_primary_alignment currently means secondary
+        if primary_only and (almnt.not_primary_alignment or almnt.supplementary):
+            continue
+
+        if almnt.read.name == current_name:
+            almnt_list.append(almnt)
+        else:
+            if bundle:
+                yield list(process_list(almnt_list))
+            else:
+                for p in process_list(almnt_list):
+                    yield p
+            current_name = almnt.read.name
+            almnt_list = [almnt]
+    if bundle:
+        yield list(process_list(almnt_list))
+    else:
+        for p in process_list(almnt_list):
+            yield p
+    if mate_missing_count[0] > 1:
+        warnings.warn("%d reads with missing mate encountered." % mate_missing_count[0])
+
+
+def pair_SAM_alignments_with_buffer(
+    alignments, max_buffer_size=30000000, primary_only=False
+):
+    """Iterate over SAM aligments with buffer, position-sorted paired-end
+
+    Args:
+        alignments (iterator of SAM/BAM alignments): the alignments to wrap
+        max_buffer_size (int): maxmal numer of alignments to keep in memory.
+        primary_only (bool): for each read, consider only the primary line
+            (SAM flag 0x900 = 0). The SAM specification requires one and only
+            one of those for each read.
+
+    Yields:
+        2-tuples with each pair of alignments.
+    """
+
+    almnt_buffer = {}
+    ambiguous_pairing_counter = 0
+    for almnt in alignments:
+        if not almnt.paired_end:
+            raise ValueError(
+                "Sequence of paired-end alignments expected, but got single-end alignment."
+            )
+        if almnt.pe_which == "unknown":
+            raise ValueError(
+                "Cannot process paired-end alignment found with 'unknown' 'pe_which' status."
+            )
+        # FIXME: almnt.not_primary_alignment currently means secondary
+        if primary_only and (almnt.not_primary_alignment or almnt.supplementary):
+            continue
+
+        matekey = (
+            almnt.read.name,
+            "second" if almnt.pe_which == "first" else "first",
+            almnt.mate_start.chrom if almnt.mate_aligned else None,
+            almnt.mate_start.pos if almnt.mate_aligned else None,
+            almnt.iv.chrom if almnt.aligned else None,
+            almnt.iv.start if almnt.aligned else None,
+            -almnt.inferred_insert_size
+            if almnt.aligned and almnt.mate_aligned
+            else None,
+        )
+
+        if matekey in almnt_buffer:
+            if len(almnt_buffer[matekey]) == 1:
+                mate = almnt_buffer[matekey][0]
+                del almnt_buffer[matekey]
+            else:
+                mate = almnt_buffer[matekey].pop(0)
+                if ambiguous_pairing_counter == 0:
+                    ambiguous_pairing_first_occurance = matekey
+                ambiguous_pairing_counter += 1
+            if almnt.pe_which == "first":
+                yield (almnt, mate)
+            else:
+                yield (mate, almnt)
+        else:
+            almntkey = (
+                almnt.read.name,
+                almnt.pe_which,
+                almnt.iv.chrom if almnt.aligned else None,
+                almnt.iv.start if almnt.aligned else None,
+                almnt.mate_start.chrom if almnt.mate_aligned else None,
+                almnt.mate_start.pos if almnt.mate_aligned else None,
+                almnt.inferred_insert_size
+                if almnt.aligned and almnt.mate_aligned
+                else None,
+            )
+            if almntkey not in almnt_buffer:
+                almnt_buffer[almntkey] = [almnt]
+            else:
+                almnt_buffer[almntkey].append(almnt)
+            if len(almnt_buffer) > max_buffer_size:
+                raise ValueError(
+                    "Maximum alignment buffer size exceeded while pairing SAM alignments."
+                )
+
+    if len(almnt_buffer) > 0:
+        warnings.warn(
+            "Mate records missing for %d records; first such record: %s."
+            % (len(almnt_buffer), str(list(almnt_buffer.values())[0][0]))
+        )
+        for almnt_list in list(almnt_buffer.values()):
+            for almnt in almnt_list:
+                if almnt.pe_which == "first":
+                    yield (almnt, None)
+                else:
+                    yield (None, almnt)
+
+    if ambiguous_pairing_counter > 0:
+        warnings.warn(
+            "Mate pairing was ambiguous for %d records; mate key for first such record: %s."
+            % (ambiguous_pairing_counter, str(ambiguous_pairing_first_occurance))
+        )
+
+
+###########################
+# variant calls
+###########################
+
+
+_re_vcf_meta_comment = re.compile("^##([a-zA-Z]+)\=(.*)$")
+
+_re_vcf_meta_descr = re.compile(
+    'ID=[^,]+,?|Number=[^,]+,?|Type=[^,]+,?|Description="[^"]+",?'
+)
+
+_re_vcf_meta_types = re.compile("[INFO|FILTER|FORMAT]")
+
+_vcf_typemap = {"Integer": int, "Float": float, "String": str, "Flag": bool}
+
+
+class VariantCall:
+    """Class representing a variant call, close to VCF format"""
+
+    def __init__(
+        self,
+        chrom=None,
+        pos=None,
+        identifier=None,
+        ref=None,
+        alt=None,
+        qual=None,
+        filtr=None,
+        info=None,
+    ):
+        """Class representing a variant call.
+
+        Arguments:
+           chrom (str): Chromosome
+           pos (int): Position on the chromosome
+           identifier (str): ID of the variant
+           ref (str): Reference allele
+           alt (str): Alternate allele
+           qual (str): Quality of the variant
+           filtr (str): Filter flag indicating if the variant passed QC.
+           info (str): Additional info on the variant
+        """
+        self.chrom = chrom
+        self.pos = pos
+        self.id = identifier
+        self.ref = ref
+        self.alt = alt
+        self.qual = qual
+        self.filter = filtr
+        self.info = info
+        self._original_line = None
+
+    @classmethod
+    def fromdict(cls, dictionary):
+        """Create a VariantCall instance from a dict of properties"""
+        ret = cls()
+        ret.chrom = dictionary["chrom"]
+        ret.pos = dictionary["pos"]
+        ret.id = dictionary["id"]
+        ret.ref = dictionary["ref"]
+        ret.alt = dictionary["alt"]
+        ret.qual = dictionary["qual"]
+        ret.filter = dictionary["filter"]
+        ret.info = dictionary["info"]
+        ret._original_line = None
+
+    @classmethod
+    def fromline(cls, line, nsamples=0, sampleids=[]):
+        """Create a VariantCall instance from a VCF line"""
+        ret = cls()
+        if nsamples == 0:
+            ret.format = None
+            (
+                ret.chrom,
+                ret.pos,
+                ret.id,
+                ret.ref,
+                ret.alt,
+                ret.qual,
+                ret.filter,
+                ret.info,
+            ) = line.rstrip("\n").split("\t", 7)
+        else:
+            lsplit = line.rstrip("\n").split("\t")
+            (
+                ret.chrom,
+                ret.pos,
+                ret.id,
+                ret.ref,
+                ret.alt,
+                ret.qual,
+                ret.filter,
+                ret.info,
+            ) = lsplit[:8]
+            ret.format = lsplit[8].split(":")
+            ret.samples = {}
+            spos = 9
+            for sid in sampleids:
+                ret.samples[sid] = dict(
+                    (name, value)
+                    for (name, value) in zip(ret.format, lsplit[spos].split(":"))
+                )
+                spos += 1
+        ret.pos = GenomicPosition(ret.chrom, int(ret.pos))
+        ret.alt = ret.alt.split(",")
+        ret._original_line = line
+        return ret
+
+    def infoline(self):
+        if self.info.__class__ == dict:
+            return ";".join(
+                map((lambda key: str(key) + "=" + str(self.info[key])), self.info)
+            )
+        else:
+            return self.info
+
+    def get_original_line(self):
+        warnings.warn(
+            "Original line is empty, probably this object was created from scratch and not from a line in a .vcf file!"
+        )
+        return self._original_line
+
+    def sampleline(self):
+        if self.format == None:
+            sys.stderr.write("No samples in this variant call!\n")
+            return ""
+        keys = self.format
+        ret = [":".join(keys)]
+        for sid in self.samples:
+            tmp = []
+            for k in keys:
+                if k in self.samples[sid]:
+                    tmp.append(self.samples[sid][k])
+            ret.append(":".join(tmp))
+        return "\t".join(ret)
+
+    def to_line(self):
+        """Convert into a VCF line"""
+        if self.format == None:
+            return (
+                "\t".join(
+                    map(
+                        str,
+                        [
+                            self.pos.chrom,
+                            self.pos.pos,
+                            self.id,
+                            self.ref,
+                            ",".join(self.alt),
+                            self.qual,
+                            self.filter,
+                            self.infoline(),
+                        ],
+                    )
+                )
+                + "\n"
+            )
+        else:
+            return (
+                "\t".join(
+                    map(
+                        str,
+                        [
+                            self.pos.chrom,
+                            self.pos.pos,
+                            self.id,
+                            self.ref,
+                            ",".join(self.alt),
+                            self.qual,
+                            self.filter,
+                            self.infoline(),
+                            self.sampleline(),
+                        ],
+                    )
+                )
+                + "\n"
+            )
+
+    def __descr__(self):
+        return "<VariantCall at %s, ref '%s', alt %s >" % (
+            str(self.pos).rstrip("/."),
+            self.ref,
+            str(self.alt).strip("[]"),
+        )
+
+    def __str__(self):
+        return "%s:'%s'->%s" % (
+            str(self.pos).rstrip("/."),
+            self.ref,
+            str(self.alt).strip("[]"),
+        )
+
+    def unpack_info(self, infodict):
+        tmp = {}
+        for token in self.info.strip(";").split(";"):
+            if re.compile("=").search(token):
+                token = token.split("=")
+                if token[0] in infodict:
+                    tmp[token[0]] = list(map(infodict[token[0]], token[1].split(",")))
+                else:
+                    tmp[token[0]] = token[1].split(",")
+                if len(tmp[token[0]]) == 1:
+                    tmp[token[0]] = tmp[token[0]][0]
+            else:  # Flag attribute found
+                tmp[token] = True
+        diff = set(infodict.keys()).difference(set(tmp.keys()))
+        for key in diff:
+            if infodict[key] == bool:
+                tmp[key] = False
+        self.info = tmp
+
+
+class VCF_Reader(FileOrSequence):
+    """Reader for VCF files.
+
+    This class parses text VCF files from scratch, independently of pysam.
+    """
+
+    def __init__(self, filename_or_sequence):
+        FileOrSequence.__init__(self, filename_or_sequence)
+        self.metadata = {}
+        self.info = {}
+        self.filters = {}
+        self.formats = {}
+        self.nsamples = 0
+        self.sampleids = []
+
+    def make_info_dict(self):
+        self.infodict = {}
+        for key in self.info.keys():
+            self.infodict[key] = _vcf_typemap[self.info[key]["Type"]]
+
+    def parse_meta(self, header_filename=None):
+        if header_filename is None:
+            the_iter = FileOrSequence.__iter__(self)
+        else:
+            the_iter = open(header_filename, "r")
+
+        for line in the_iter:
+            if line.startswith("#"):
+                if line.startswith("##"):
+                    mo = _re_vcf_meta_comment.match(line)
+                    if mo:
+                        value = mo.group(2)
+                        if mo.group(1) == "INFO":
+                            value = dict(
+                                e.rstrip(",").split("=", 1)
+                                for e in _re_vcf_meta_descr.findall(value)
+                            )
+                            key = value["ID"]
+                            del value["ID"]
+                            self.info[key] = value
+                        elif mo.group(1) == "FILTER":
+                            value = dict(
+                                e.rstrip(",").split("=", 1)
+                                for e in _re_vcf_meta_descr.findall(value)
+                            )
+                            key = value["ID"]
+                            del value["ID"]
+                            self.filters[key] = value
+                        elif mo.group(1) == "FORMAT":
+                            value = dict(
+                                e.rstrip(",").split("=", 1)
+                                for e in _re_vcf_meta_descr.findall(value)
+                            )
+                            key = value["ID"]
+                            del value["ID"]
+                            self.formats[key] = value
+                        else:
+                            self.metadata[mo.group(1)] = mo.group(2)
+                else:
+                    self.sampleids = line.rstrip("\t\n").split("\t")[9:]
+                    self.nsamples = len(self.sampleids)
+                continue
+            else:
+                break
+
+    def meta_info(self, header_filename=None):
+        ret = []
+        if header_filename is None:
+            the_iter = FileOrSequence.__iter__(self)
+        else:
+            the_iter = open(header_filename, "r")
+
+        for line in the_iter:
+            if line.startswith("#"):
+                ret.append(line)
+            else:
+                break
+        return ret
+
+    def __iter__(self):
+        for line in FileOrSequence.__iter__(self):
+            if line == "\n" or line.startswith("#"):
+                continue
+            vc = VariantCall.fromline(line, self.nsamples, self.sampleids)
+            yield vc
+
+
+class WiggleReader(FileOrSequence):
+    def __init__(self, filename_or_sequence, verbose=True):
+        FileOrSequence.__init__(self, filename_or_sequence)
+        self.attributes = {}
+        self.stepType = "none"
+        self.verbose = verbose
+
+    def __iter__(self):
+        span = 1
+        pos = None
+        step = None
+        chrom = None
+        for line in FileOrSequence.__iter__(self):
+            if line.startswith("track"):
+                fields = shlex.split(line)[1:]
+                self.attributes = dict(
+                    [(p[0], p[1].strip('"')) for p in [x.split("=") for x in fields]]
+                )
+            elif line.startswith("fixedStep"):  # do fixed step stuff
+                self.stepType = "fixed"
+                fields = shlex.split(line)[1:]
+                declarations = dict(
+                    [(p[0], p[1].strip('"')) for p in [x.split("=") for x in fields]]
+                )
+                pos = int(declarations["start"])
+                step = int(declarations["step"])
+                chrom = declarations["chrom"]
+                if "span" in declarations:
+                    span = int(declarations["span"])
+                else:
+                    span = 1
+            elif line.startswith("variableStep"):  # do variable step stuff
+                self.stepType = "variable"
+                fields = shlex.split(line)[1:]
+                declarations = dict(
+                    [(p[0], p[1].strip('"')) for p in [x.split("=") for x in fields]]
+                )
+                chrom = declarations["chrom"]
+                if "span" in declarations:
+                    span = int(declarations["span"])
+                else:
+                    span = 1
+            elif line.startswith("browser") or line.startswith(
+                "#"
+            ):  # Comment or ignored
+                if self.verbose:
+                    print("Ignored line:", line)
+                continue
+            else:
+                if self.stepType == "fixed":
+                    yield (
+                        GenomicInterval(chrom, pos, pos + span, "."),
+                        float(line.strip()),
+                    )
+                    pos += step
+                elif self.stepType == "variable":
+                    tmp = line.strip().split(" ")
+                    pos = int(tmp[0])
+                    yield (GenomicInterval(chrom, pos, pos + span, "."), float(tmp[1]))
+
+
+class BAM_Reader:
+    """Parser for SAM/BAM/CRAM files.
+
+    This is a thin wrapper on top of pysam.AlignmentFile. It detects
+    automatically whether the input file is text (SAM) or binary (BAM/CRAM) via
+    the HTSlib library.
+    """
+
+    def __init__(self, filename, check_sq=True):
+        """Parser for SAM/BAM/CRAM files, a thin layer over pysam.AlignmentFile.
+
+        Arguments:
+           filename (str, Path): The path to the input file to read
+           check_sq (bool): check if SQ entries are present in header
+        """
+
+        global pysam
+        self.filename = filename
+        self.sf = None
+        self.record_no = -1
+        self.check_sq = check_sq
+        try:
+            import pysam
+        except ImportError:
+            sys.stderr.write("Please install pysam to use the BAM_Reader class")
+            raise
+        self._open_file()
+
+    def _open_file(self):
+        self.sf = pysam.AlignmentFile(
+            self.filename,
+            check_sq=self.check_sq,
+        )
+
+    def close(self):
+        """Close the BAM file for clean up"""
+        self.sf.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def __iter__(self):
+        self.record_no = 0
+        for pa in self.sf:
+            yield SAM_Alignment.from_pysam_AlignedSegment(pa, self.sf)
+            self.record_no += 1
+
+    def fetch(self, reference=None, start=None, end=None, region=None):
+        self.record_no = 0
+        try:
+            for pa in self.sf.fetch(reference, start, end, region):
+                yield SAM_Alignment.from_pysam_AlignedRead(pa, self.sf)
+                self.record_no += 1
+        except ValueError as e:
+            if e.message == "fetch called on bamfile without index":
+                print("Error: ", e.message)
+                print(
+                    "Your bam index file is missing or wrongly named, convention is that file 'x.bam' has index file 'x.bam.bai'!"
+                )
+            else:
+                raise
+        except:
+            raise
+
+    def get_line_number_string(self):
+        if self.record_no == -1:
+            return "unopened file %s" % (self.filename)
+        else:
+            return "record #%d in file %s" % (self.record_no, self.filename)
+
+    def __getitem__(self, iv):
+        if not isinstance(iv, GenomicInterval):
+            raise TypeError(
+                "Use a HTSeq.GenomicInterval to access regions within .bam-file!"
+            )
+        if self.sf is None:
+            self._open_file()
+
+        if (hasattr(self.sf, "_hasIndex") and (not self.sf._hasIndex())) or (
+            not self.sf.has_index()
+        ):
+            raise ValueError("The .bam-file has no index, random-access is disabled!")
+        for pa in self.sf.fetch(iv.chrom, iv.start + 1, iv.end):
+            yield SAM_Alignment.from_pysam_AlignedRead(pa, self.sf)
+
+    def get_header_dict(self):
+        return self.sf.header
+
+    def get_template(self):
+        return self.sf
+
+
+# NOTE: this will be deprecated
+SAM_Reader = BAM_Reader
+
+
+class BAM_Writer:
+    """Writer for SAM/BAM/CRAM files, a thin layer over pysam.AlignmentFile"""
+
+    def __init__(
+        self,
+        filename,
+        template=None,
+        referencenames=None,
+        referencelengths=None,
+        text=None,
+        header=None,
+    ):
+        try:
+            import pysam
+        except ImportError:
+            sys.stderr.write("Please Install pysam to use the BAM_Writer Class")
+            raise
+
+        self.filename = filename
+        self.template = template
+        self.referencenames = referencenames
+        self.referencelengths = referencelengths
+        self.text = text
+        self.header = header
+        self.sf = pysam.AlignmentFile(
+            self.filename,
+            mode="wb",
+            template=self.template,
+            referencenames=self.referencenames,
+            referencelengths=self.referencelengths,
+            text=self.text,
+            header=self.header,
+        )
+
+    @classmethod
+    def from_BAM_Reader(cls, fn, br):
+        return BAM_Writer(filename=fn, header=br.get_header_dict())
+
+    def write(self, alnmt):
+        self.sf.write(alnmt.to_pysam_AlignedSegment(self.sf))
+
+    def close(self):
+        self.sf.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+
+class BED_Reader(FileOrSequence):
+    """Reader for BED files.
+
+    This class simply parses the BED as a text file and converts the various
+    columns into HTSeq objects. For each row it extracts:
+
+    - a GenomicInterval with chromosome equal to the first column, start and
+      end to the second and third columns, and strandedness equal to the sixth
+      column;
+
+    - a GenomicFeature with name equal to the fourth column (or "unnamed"),
+      type set to "BED line", score equal to the fifth column and interval set
+      as the GenomicInterval above.
+
+    - If the "thick" start and end are provided in the BED file as seventh and
+      eight columns, they are stored as a GenomicInterval in the "thick"
+      attribute of the GenomicFeature above (i.e. feature.thick).
+
+    - If the itemRgb color line is provided in the BED file as ninth column, it
+      is stored as "itemRgb" attribute in the GenomicFeature above (i.e.
+      feature.itemRgb).
+
+    - The blockCount, blockStart, blockSizes columns (tenth to twelth) are
+      currently ignored, this might change in the future.
+
+    Rows starting with "track" are skipped.
+    """
+
+    def __init__(self, filename_or_sequence):
+        FileOrSequence.__init__(self, filename_or_sequence)
+
+    def __iter__(self):
+        for line in FileOrSequence.__iter__(self):
+            if line.startswith("track"):
+                continue
+            fields = line.split()
+            if len(fields) < 3:
+                raise ValueError("BED file line contains less than 3 fields")
+            if len(fields) > 12:
+                raise ValueError("BED file line contains more than 12 fields")
+            iv = GenomicInterval(
+                fields[0],
+                int(fields[1]),
+                int(fields[2]),
+                fields[5] if len(fields) > 5 else ".",
+            )
+            f = GenomicFeature(
+                fields[3] if len(fields) > 3 else "unnamed", "BED line", iv
+            )
+            f.score = float(fields[4]) if len(fields) > 4 else None
+            f.thick = (
+                GenomicInterval(iv.chrom, int(fields[6]), int(fields[7]), iv.strand)
+                if len(fields) > 7
+                else None
+            )
+            f.itemRgb = (
+                [int(a) for a in fields[8].split(",")] if len(fields) > 8 else None
+            )
+            yield (f)
+
+
+class BigWig_Reader:
+    """A simple reader for BigWig files (using pyBigWig)"""
+
+    def __init__(self, filename):
+        """Parser for BigWig files, a thin layer over pyBigWig.
+
+        Arguments:
+           filename (str, Path): The path to the input file to read
+        """
+        global pyBigWig
+
+        try:
+            import pyBigWig
+        except ImportError:
+            sys.stderr.write("Please Install pyBigWig to use the BigWig_Reader Class")
+            raise
+
+        self.filename = filename
+        self.sf = pyBigWig.open(filename)
+
+    def close(self):
+        self.sf.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def chroms(self):
+        """Return the list of chromosomes and their lengths, as a dictionary.
+
+        Example:
+
+        bw.chroms() -> {'chr1': 4568999, 'chr2': 87422, ...}
+        """
+        return self.sf.chroms()
+
+    def intervals(self, chrom, strand=".", raw=False):
+        """Lazy iterator over genomic intervals
+
+        Args:
+            chrom (str): The chromosome/scaffold to find intervals for.
+            strand ('.', '+', or '-'): Strandedness of the yielded
+              GenomicInterval. If raw=True, this argument is ignored.
+            raw (bool): If True, return the raw triplet from pyBigWig. If False,
+              return the result wrapped in a GenomicInterval with the
+              appropriate strandedness.
+        """
+        for chrom, start, end in self.sf.intervals(chrom):
+            if raw:
+                yield (chrom, start, end)
+            else:
+                yield GenomicInterval(chrom, start, end, strand=strand)
+
+
+# TODO: make a BigWig_Writer class with buffered write operations, i.e. move it
+# from the .pyx file. One would probably want to lazy out the header by element
+# as well.