REDItools3 3.1a0__py3-none-any.whl

REDItools3-3.1a0.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: REDItools3
+Version: 3.1a0
+Author: Ernesto Picardi
+Author-email: Adam Handen <adam.handen@gmail.com>
+Project-URL: homepage, https://github.com/BioinfoUNIBA/REDItools3
+Project-URL: repository, https://github.com/BioinfoUNIBA/REDItools3
+Project-URL: issues, https://github.com/BioinfoUNIBA/REDItools3/issues
+Keywords: bioinformatics,RNA,RNA-editing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License (GPL)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pysam >=0.22.0
+Requires-Dist: sortedcontainers >=2.4.0
+
+# REDItools3
+A new REDItools implementation to speed-up the RNA editing profiling in massive RNAseq data
+
+# Installation
+Install from PyPi.
+`pip install REDItools3`
+
+Use the whl file under the dist directory.
+`pip install dist/reditools-0.1-py3-none-any.whl`
+
+# Usage
+Once installed, reditools can be run from the commandline.
+`python -m reditools`

REDItools3-3.1a0.dist-info/RECORD

@@ -0,0 +1,21 @@
+reditools/__init__.py,sha256=7nSB0hrQznxrn6l95cv_pSonJTG6jZCQdbn7aT1TtvY,46
+reditools/__main__.py,sha256=mWJ9O2LDiOpBWDBJJUN7OiM4SyltW-kVXXAGBe_JxgQ,842
+reditools/alignment_file.py,sha256=YFyCEhMek2t93DpmpwEst5v3gDZkmRotbd6Fy_mP0aE,4258
+reditools/alignment_manager.py,sha256=_FXwvqGWoXRdzVrwBxki2heaVZA2cQbGXqCopr-g1Hs,4138
+reditools/analyze.py,sha256=u38yN5DmXUCW8nQP_BMfsXuvb59rFO12di5cYT8Ye58,15280
+reditools/compiled_position.py,sha256=v540uUEie_HHUwsYQmBqeeOkUvtYlcnWj1v8gAhLUiE,3858
+reditools/compiled_reads.py,sha256=7Hm5f7g1T8q1zDOOxZUD7aZax9b7SdQ0PlmT93hmcaE,4154
+reditools/fasta_file.py,sha256=KBsJBs7OnBpew2PGWGp0mTxPLlpBmRrtXL4uvQw4t34,2212
+reditools/file_utils.py,sha256=AJjU9leOxSou5U_4RAgapR9PGQz0OYQlkCudvTcXGeQ,3284
+reditools/homopolymerics.py,sha256=BCYXBJa6YuouzccFisBFOtGfZAEOSqeqJsO-c37At84,2123
+reditools/index.py,sha256=K3JQTMx4ojUUiPQTDMDsoYoFQQ_o-ZNqTrh5dIVFVSQ,7398
+reditools/logger.py,sha256=u4L2SYxy4vJ4KDHEymd0b1sCa8BXXHchx8LR_wcFq1A,1210
+reditools/reditools.py,sha256=Rb5bllqjE1wHti98p-v2t4Vu-YEvZgNv-FXcUPgDVO0,12725
+reditools/region.py,sha256=_BiKDc5lCl1snjkokRiUWOgzA57ME3yLydEIwK9ku7U,3780
+reditools/rtchecks.py,sha256=tkaosQDBc2XN_RlVMtNwrxZjCQoQo2bWfQISROXCmKA,8221
+reditools/utils.py,sha256=a2qfhMcrH2QlK-JoR-HHF6_bnlo5v3jihAqqknvVIjc,2733
+REDItools3-3.1a0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+REDItools3-3.1a0.dist-info/METADATA,sha256=EPD47hLxZoozfc0Gd4uFPOaid9uz81DkWI4Pkv0STpo,1289
+REDItools3-3.1a0.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
+REDItools3-3.1a0.dist-info/top_level.txt,sha256=wrvvbFXhmNg7s6LQqjlV_fVQYUZOOpF93IcMu_hBCx4,10
+REDItools3-3.1a0.dist-info/RECORD,,

REDItools3-3.1a0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

REDItools3-3.1a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+reditools

reditools/__init__.py

@@ -0,0 +1 @@
+"""REDItools3 - RNA Editing Analysis Tool."""

reditools/__main__.py

@@ -0,0 +1,37 @@
+"""Commandline tool for REDItools."""
+
+import sys
+
+from reditools import analyze, homopolymerics, index
+
+
+def usage():
+    """Print program usage."""
+    print("""usage: reditools {analyze,find-repeats,index}
+
+REDItools3
+
+Run Modes:
+  analyze            Find editing events in one or more alignment files.
+
+  find-repeats       Find repetitive elements in a genome.
+
+  index              Calculate editing indices from the output of `analyze`
+                     mode.
+""")
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        command = sys.argv.pop(1)
+        match command:
+            case 'analyze':
+                analyze.main()
+            case 'find-repeats':
+                homopolymerics.main()
+            case 'index':
+                index.main()
+            case _:
+                usage()
+    else:
+        usage()

reditools/alignment_file.py

@@ -0,0 +1,146 @@
+"""Wrappers for pysam files."""
+
+from pysam.libcalignmentfile import AlignmentFile as PysamAlignmentFile
+
+
+class RTAlignmentFile(PysamAlignmentFile):
+    """Wrapper for pysam.AlignmentFile to provide filtering on fetch."""
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Create a wrapper for pysam.AlignmentFile.
+
+        Parameters:
+            *args (list): Positional arguments for pysam.FastaFile()
+            **kwargs (dict): Keyword arguments for pysam.FastaFile()
+
+        Returns:
+            PysamAlignmentFile
+        """
+        kwargs.pop('min_quality', None)
+        kwargs.pop('min_length', None)
+        return PysamAlignmentFile.__new__(cls, *args, **kwargs)
+
+    def __init__(self, *args, min_quality=0, min_length=0, **kwargs):
+        """
+        Create a wrapper for pysam.AlignmentFile.
+
+        Parameters:
+            *args (list): Positional arguments for pysam.FastaFile()
+            min_quality (int): Minimum read quality
+            min_length (int): Minimum read length
+            **kwargs (dict): Keyword arguments for pysam.FastaFile()
+        """
+        PysamAlignmentFile.__init__(self)
+
+        self._checklist = []
+
+        if min_quality > 0:
+            self._min_quality = min_quality
+            self._checklist.append(self._check_quality)
+
+        if min_length > 0:
+            self._min_length = min_length
+            self._checklist.append(self._check_length)
+
+    @property
+    def exclude_reads(self):
+        """
+        Names of reads not to be fetched.
+
+        Returns:
+            iterable
+        """
+        return self._exclude_reads
+
+    @exclude_reads.setter
+    def exclude_reads(self, read_names):
+        """
+        Provide a list of read names to be skipped during fetch.
+
+        Parameters:
+            read_names (iterable): Reads to skip
+        """
+        self._exclude_reads = set(read_names)
+        self._checklist.append(self._check_read_name)
+
+    def fetch(self, *args, **kwargs):
+        """
+        Fetch reads aligned in a region.
+
+        Parameters:
+            *args (list): Positional arguments for pysam.FastaFile.fetch
+            *kwargs (list): Keyword arguments for pysam.FastaFile.fetch
+
+        Yields:
+            Reads
+        """
+        if 'region' in kwargs:
+            kwargs['region'] = str(kwargs['region'])  # noqa:WPS529
+        try:
+            iterator = super().fetch(*args, **kwargs)
+        except ValueError:
+            return
+        for read in iterator:
+            if self._check_read(read):
+                yield read
+
+    def fetch_by_position(self, *args, **kwargs):
+        """
+        Retrieve reads that all start at the same point on the reference.
+
+        Parameters:
+            *args (list): Positional arguments for fetch
+            **kwargs (dict): Named arguments for fetch
+
+        Yields:
+            Lists containing reads
+        """
+        iterator = self.fetch(*args, **kwargs)
+
+        first_read = next(iterator, None)
+        if first_read is None:
+            return
+
+        reads = [first_read]
+        ref_start = first_read.reference_start
+
+        for read in iterator:
+            if read.reference_start == ref_start:
+                reads.append(read)
+            else:
+                yield reads
+                reads = [read]
+                ref_start = read.reference_start
+        yield reads
+
+    # 77: NOT_MAPPED
+    # 141: NOT_MAPPED
+    # 512: QC_FAIL
+    # 256: IS_SECONDARY
+    # 2048: IS_SUPPLEMENTARY
+    # 1024: IS_DUPLICATE
+    _flags_to_toss = {77, 141, 512, 256, 2048, 1024}
+    _paired_flags_to_keep = {99, 147, 83, 163}
+
+    def _check_quality(self, read):
+        return read.mapping_quality >= self._min_quality
+
+    def _check_length(self, read):
+        return read.query_length >= self._min_length
+
+    def _check_read_name(self, read):
+        return read.query_name not in self._exclude_reads
+
+    def _check_read(self, read):
+        if read.has_tag('SA'):
+            return False
+        if read.flag in self._flags_to_toss:
+            return False
+        if read.is_paired and read.flag not in self._paired_flags_to_keep:
+            return False
+
+        for check in self._checklist:
+            if not check(read):
+                return False
+        return True

reditools/alignment_manager.py

@@ -0,0 +1,136 @@
+"""Wrappers for pysam files."""
+from itertools import chain
+
+from reditools.alignment_file import RTAlignmentFile
+
+
+class ReadGroupIter(object):
+    """Manages multiple fetch iterators."""
+
+    _iter_idx = 0
+    _reads_idx = 1
+    _start_idx = 2
+
+    def __init__(self, fetch_iters):
+        """
+        Combine multiple fetch iterators.
+
+        Parameters:
+            fetch_iters (iterable): The iterators to combine.
+        """
+        self._read_groups = []
+        for itr in fetch_iters:
+            reads = next(itr, None)
+            if reads is None:
+                continue
+            start = reads[0].reference_start
+            self._read_groups.append({
+                self._iter_idx: itr,
+                self._reads_idx: reads,
+                self._start_idx: start,
+            })
+
+    def is_empty(self):
+        """
+        Check if there are still reads left.
+
+        Returns:
+            bool: True if empty, else False
+        """
+        return not self._read_groups
+
+    def next(self):
+        """
+        Retrieve a list of reads that all start at the same position.
+
+        Returns:
+            list: Reads
+        """
+        position = self._find_start()
+        reads = []
+        for idx in range(len(self._read_groups) - 1, -1, -1):
+            group = self._read_groups[idx]
+            if group[self._start_idx] == position:
+                reads.append(group[self._reads_idx])
+                next_reads = next(group[self._iter_idx], None)
+                if next_reads is None:
+                    self._read_groups.pop(idx)
+                else:
+                    self._read_groups[idx] = {
+                        self._iter_idx: group[self._iter_idx],
+                        self._reads_idx: next_reads,
+                        self._start_idx: next_reads[0].reference_start,
+                    }
+        return reads
+
+    def _find_start(self):
+        return min(group[self._start_idx] for group in self._read_groups)
+
+
+class AlignmentManager(object):
+    """
+    Manage multiple RTAlignmentFiles with a single fetch.
+
+    Attributes:
+        min_quality (int): Minimum read quality (applied during add_file)
+        min_length (int): Minimum read length (applied during add_file)
+    """
+
+    def __init__(self, *args, **kwargs):
+        """
+        Create a new manager.
+
+        Parameters:
+            *args (list): positional arguments for PysamFastaFile
+                constructor
+            **kwargs (dict): named arguments for PysamFastaFile
+                constructor
+        """
+        self._bam_args = args
+        self._bam_kwargs = kwargs
+        self._bams = []
+        self.min_quality = 0
+        self.min_length = 0
+        self.file_list = []
+
+    def add_file(self, fname, exclude_reads=None):
+        """
+        Add an alignment file to the manager for analysis.
+
+        Parameters:
+            fname (str): Path to BAM file
+            exclude_reads (set): Read names not to skip
+        """
+        new_file = RTAlignmentFile(
+            fname,
+            *self._bam_args,
+            min_quality=self.min_quality,
+            min_length=self.min_length,
+            **self._bam_kwargs,
+        )
+        new_file.check_index()
+        if exclude_reads:
+            new_file.exclude_reads = exclude_reads
+        self._bams.append(new_file)
+        self.file_list.append(fname)
+
+    def fetch_by_position(self, *args, **kwargs):
+        """
+        Perform combine fetch_by_position for all managed files.
+
+        Parameters:
+            *args (list): Positional arguments for
+                RTAlignmentFile.fetch_by_position
+            **kwargs (dict): Named arguments for
+                RTAlignmentFile.fetch_by_position
+
+        Yields:
+            list: reads from all managed files that begin at the same position.
+        """
+        iters = [bam.fetch_by_position(*args, **kwargs) for bam in self._bams]
+        rgi = ReadGroupIter(iters)
+        while not rgi.is_empty():
+            reads = list(chain(*rgi.next()))
+            self.position = reads[0].reference_start
+            self.contig = reads[0].reference_name
+            yield reads