REDItools3 3.4__tar.gz → 3.5__tar.gz

{reditools3-3.4 → reditools3-3.5}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: REDItools3
-Version: 3.4
+Version: 3.5
 Author: Ernesto Picardi
 Author-email: Adam Handen <adam.handen@gmail.com>
+License-Expression: GPL-3.0-or-later
 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
@@ -10,7 +11,6 @@ Keywords: bioinformatics,RNA,RNA-editing
 Classifier: Development Status :: 5 - Production/Stable
 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.7

{reditools3-3.4 → reditools3-3.5}/REDItools3.egg-info/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: REDItools3
-Version: 3.4
+Version: 3.5
 Author: Ernesto Picardi
 Author-email: Adam Handen <adam.handen@gmail.com>
+License-Expression: GPL-3.0-or-later
 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
@@ -10,7 +11,6 @@ Keywords: bioinformatics,RNA,RNA-editing
 Classifier: Development Status :: 5 - Production/Stable
 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.7

{reditools3-3.4 → reditools3-3.5}/REDItools3.egg-info/SOURCES.txt

@@ -21,5 +21,6 @@ reditools/index.py
 reditools/logger.py
 reditools/reditools.py
 reditools/region.py
+reditools/region_collection.py
 reditools/rtchecks.py
 reditools/utils.py

{reditools3-3.4 → reditools3-3.5}/pyproject.toml

@@ -4,7 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "REDItools3"
-version = "v3.4"
+version = "v3.5"
+license = "GPL-3.0-or-later"
 authors = [
   { name="Adam Handen", email="adam.handen@gmail.com" },
   { name="Ernesto Picardi" },
@@ -20,7 +21,6 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: GNU General Public License (GPL)",
     "Operating System :: MacOS :: MacOS X",
     "Operating System :: Unix",
     "Programming Language :: Python :: 3.7",

{reditools3-3.4 → reditools3-3.5}/reditools/analyze.py

@@ -80,27 +80,29 @@ def setup_rtools(options):  # noqa:WPS213,WPS231
 
     if options.load_omopolymeric_file:
         regions = file_utils.read_bed_file(options.load_omopolymeric_file)
-        rtools.exclude(regions)
-
-    if options.splicing_file:
-        rtools.splice_positions = file_utils.load_splicing_file(
-            options.splicing_file,
-            options.splicing_span,
-        )
+        rtools.add_exclude_regions(regions)
 
     if options.variants:
         rtools.specific_edits = [_.upper() for _ in options.variants]
 
     if options.bed_file:
-        regions = file_utils.read_bed_file(options.bed_file)
-        rtools.target_positions = regions
+        for fname in options.bed_file:
+            regions = file_utils.read_bed_file(fname)
+            rtools.add_target_regions(regions)
     if options.exclude_regions:
         for fname in options.exclude_regions:
             regions = file_utils.read_bed_file(fname)
-            rtools.exclude(regions)
+            rtools.add_exclude_regions(regions)
     if options.reference:
         rtools.add_reference(options.reference)
 
+    if options.splicing_file:
+        rtools.splice_positions = file_utils.load_splicing_file(
+            options.splicing_file,
+            options.splicing_span,
+        )
+        rtools.add_exclude_regions(regions)
+
     rtools.min_base_position = options.min_base_position
     rtools.max_base_position = options.max_base_position
     rtools.min_base_quality = options.min_base_quality
@@ -148,7 +150,8 @@ def region_args(bam_fname, region, window):
     return args
 
 
-def write_results(rtools, sam_manager, file_name, region, output_format):
+def write_results(rtools, sam_manager, file_name, region, output_format,
+                  temp_dir):
     """
     Write the results from a REDItools analysis to a temporary file.
 
@@ -162,7 +165,7 @@ def write_results(rtools, sam_manager, file_name, region, output_format):
     Returns:
         string: Name of the temporary file.
     """
-    with NamedTemporaryFile(mode='w', delete=False) as stream:
+    with NamedTemporaryFile(mode='w', delete=False, dir=temp_dir) as stream:
         writer = csv.writer(stream, **output_format)
         for rt_result in rtools.analyze(sam_manager, region):
             variants = rt_result.variants
@@ -207,12 +210,14 @@ def run(options, in_queue, out_queue):
                 options.file,
                 region,
                 options.output_format,
+                options.temp_dir,
             )
             out_queue.put((idx, file_name))
     except Exception as exc:
         if options.debug:
             traceback.print_exception(*sys.exc_info())
         sys.stderr.write(f'[ERROR] ({type(exc)}) {exc}\n')
+        sys.exit(1)
 
 
 def parse_options():  # noqa:WPS213
@@ -269,13 +274,6 @@ def parse_options():  # noqa:WPS213
         '--load-omopolymeric-file',
         help='BED file of omopolymeric positions.',
     )
-    parser.add_argument(
-        '-os',
-        '--omopolymeric-span',
-        type=int,
-        default=5,
-        help='The omopolymeric span.',
-    )
     parser.add_argument(
         '-sf',
         '--splicing-file',
@@ -394,6 +392,7 @@ def parse_options():  # noqa:WPS213
     parser.add_argument(
         '-B',
         '--bed_file',
+        nargs='+',
         help='Only analyze regions in the provided BED file.',
     )
     parser.add_argument(
@@ -403,6 +402,9 @@ def parse_options():  # noqa:WPS213
         type=int,
         default=1,
     )
+    parser.add_argument(
+        '--temp-dir',
+        help='Location to save temporary files')
     parser.add_argument(
         '-w',
         '--window',
@@ -433,7 +435,7 @@ def parse_options():  # noqa:WPS213
         '-v',
         '--variants',
         nargs='*',
-        default=['CT', 'AG'],
+        default=['all'],
         help='Which editing events to report. Edits should be two characters, '
         'separated by spaces. Use "all" to report all variants.',
     )

{reditools3-3.4 → reditools3-3.5}/reditools/compiled_reads.py

@@ -28,11 +28,12 @@ class CompiledReads(object):
         """
         self._nucleotides = {}
         if strand == 0:
-            self.get_strand = lambda read: read.is_reverse
+            self.get_strand = lambda _: 2
+        elif strand == 1:
+            self.get_strand = self._get_strand_one
         else:
-            self.get_strand = self._get_strand
+            self.get_strand = self._get_strand_two
 
-        self._strand_one = strand == 1
         self._ref = None
         self._ref_seq = self._get_ref_from_read
 
@@ -127,5 +128,10 @@ class CompiledReads(object):
                 if qualities[offset] >= self._qc['min_base_quality']:
                     yield (ref_pos, seq[offset], qualities[offset], ref_base)
 
-    def _get_strand(self, read):
-        return read.is_read2 ^ self._strand_one ^ read.is_reverse
+    def _get_strand_one(self, read):
+        return read.is_read1 and not read.is_reverse or \
+            read.is_read2 and read.is_reverse
+
+    def _get_strand_two(self, read):
+        return read.is_read1 and read.is_reverse or \
+            read.is_read2 and not read.is_reverse

{reditools3-3.4 → reditools3-3.5}/reditools/fasta_file.py

@@ -49,8 +49,6 @@ class RTFastaFile(PysamFastaFile):
         if contig != self._contig_name:
             self._update_contig_cache(contig)
         try:
-            if len(position) == 1:
-                return self._contig_cache[position[0]]
             return [self._contig_cache[idx] for idx in position]
         except IndexError as exc:
             raise IndexError(

{reditools3-3.4 → reditools3-3.5}/reditools/reditools.py

@@ -11,6 +11,7 @@ from reditools.compiled_reads import CompiledReads
 from reditools.fasta_file import RTFastaFile
 from reditools.logger import Logger
 from reditools.rtchecks import RTChecks
+from reditools.region_collection import RegionCollection
 
 
 class RTResult(object):
@@ -124,9 +125,8 @@ class REDItools(object):
 
         self._min_read_quality = 0
 
-        self._target_positions = False
-        self._exclude_positions = {}
-        self._splice_positions = []
+        self._target_regions = RegionCollection()
+        self._exclude_regions = RegionCollection()
         self._specific_edits = None
 
         self.reference = None
@@ -174,44 +174,25 @@ class REDItools(object):
         return True
 
     @property
-    def splice_positions(self):
+    def target_regions(self):
         """
-        Known splice sites.
+        Only report results for these locations.
 
         Returns:
             list
         """
-        return self._splice_positions
+        return self._target_regions
 
-    @splice_positions.setter
-    def splice_positions(self, regions):
-        function = self._rtqc.check_splice_positions
-        if regions:
-            self._splice_positions = utils.enumerate_positions(regions)
-            self._rtqc.add(function)
-        else:
-            self._splice_positions = []
-            self._rtqc.discard(function)
-
-    @property
-    def target_positions(self):
+    def add_target_regions(self, regions):
         """
         Only report results for these locations.
 
-        Returns:
-            list
+        Parameters:
+            regions (iterable): List of Region objects.
         """
-        return self._target_positions
-
-    @target_positions.setter
-    def target_positions(self, regions):
-        function = self._rtqc.check_target_positions
         if regions:
-            self._target_positions = utils.enumerate_positions(regions)
-            self._rtqc.add(function)
-        else:
-            self._target_positions = False
-            self._rtqc.discard(function)
+            self._target_regions.add_regions(regions)
+            self._rtqc.add(self._rtqc.check_target_positions)
 
     @property
     def log_level(self):
@@ -291,14 +272,20 @@ class REDItools(object):
             self._rtqc.discard(function)
 
     @property
-    def exclude_positions(self):
+    def exclude_regions(self):
+        """Regions to exclude from analysis"""
+        return self._exclude_regions
+
+    def add_exclude_regions(self, regions):
         """
-        Genomic positions NOT to include in output.
+        Regions to exclude from analysis
 
-        Returns:
-            Dictionary of contigs to positions
+        Parameters:
+            regions (iterable): List of Region objects.
         """
-        return self._exclude_positions
+        if regions:
+            self._exclude_regions.add_regions(regions)
+            self._rtqc.add(self._rtqc.check_exclusions)
 
     @property
     def max_alts(self):
@@ -323,10 +310,10 @@ class REDItools(object):
         """
         for region in regions:
             contig = region.contig
-            old_pos = self._exclude_positions.get(contig, set())
-            self._exclude_positions[contig] = old_pos | region.enumerate()
-        function = self._rtqc.check_exclusion
-        if self._exclude_positions:
+            old_pos = self._exclude_regions.get(contig, set())
+            self._exclude_regions[contig] = old_pos | region.enumerate()
+        function = self._rtqc.check_exclusions
+        if self._exclude_regions:
             self._rtqc.add(function)
         else:
             self._rtqc.discard(function)
@@ -396,7 +383,8 @@ class REDItools(object):
             if column is None:
                 self.log(Logger.debug_level, 'Bad column - skipping')
                 continue
-            if self._specific_edits and not self._specific_edits & set(column.variants):
+            if self._specific_edits and \
+                    not self._specific_edits & set(column.variants):
                 self.log(
                     Logger.debug_level,
                     'Requested edits not found - skipping',

{reditools3-3.4 → reditools3-3.5}/reditools/region.py

@@ -30,8 +30,11 @@ class Region(object):
             if 'contig' not in kwargs:
                 raise ValueError('Region constructor requires a contig.')
             self.contig = kwargs['contig']
-            self.start = self._to_int(kwargs.get('start', 1))
-            self.stop = self._to_int(kwargs.get('stop', None))
+            self.start = self._to_int(kwargs.get('start', 1)) - 1
+            if 'stop' in kwargs:
+                self.stop = self._to_int(kwargs['stop']) - 1
+            else:
+                self.stop = None
 
     def __str__(self):
         """
@@ -40,12 +43,11 @@ class Region(object):
         Returns:
             (str): contig:start-stop
         """
-        region = self.contig
-        if self.start:
-            region = f'{region}:{self.start}'
+        if self.start > 0:
             if self.stop:
-                region = f'{region}-{self.stop}'
-        return region
+                return f'{self.contig}:{self.start}-{self.stop + 1}'
+            return f'{self.contig}:{self.start}'
+        return self.contig
 
     def split(self, window):
         """
@@ -111,7 +113,7 @@ class Region(object):
         if not region:
             return None
         contig = region[0]
-        start = None
+        start = 0
         stop = None
 
         if len(region) > 3:

reditools3-3.5/reditools/region_collection.py

@@ -0,0 +1,78 @@
+"""Genomic Region Collection."""
+
+
+class RegionCollection(object):
+    """Collections of REDItools3 region objects. This class is meant to
+    provide fast lookups of overlaps, and so behaves as a queue."""
+
+    def __init__(self):
+        """
+        Creates a new region collection.
+
+        """
+
+        self._regions = {}
+        self._last_index = None
+        self._last_contig = None
+        self._sorted = False
+
+    def _sort(self):
+        for contig, regions in self._regions.items():
+            self._regions[contig] = sorted(
+                regions,
+                key=lambda _: (_.start, _.stop),
+            )
+        self._sorted = True
+
+    def contains(self, contig, position):
+        """
+        Checks whether the given position or range overlaps with the
+        collection.
+
+        Parameters:
+            contig (str): Chromomsome/contig name from reference.
+            position_start (int): Position to check for.
+
+        Returns:
+            True if there is an overlap, False otherwise.
+        """
+        if not self._sorted:
+            self._sort()
+
+        if contig != self._last_contig:
+            self._last_contig = contig
+            self._last_index = 0
+
+        for i in range(self._last_index, len(self._regions.get(contig, []))):
+            self._last_index = i
+            region = self._regions[contig][i]
+            if position < region.start:
+                return False
+            if position >= region.start and \
+                    (region.stop is None or position < region.stop):
+                return True
+        self._last_index += 1
+
+        return False
+
+    def add_region(self, region):
+        """
+        Add a region to the collection.
+
+        Parameters:
+            region (Region): region to add.
+        """
+        self._sorted = False
+        if region.contig not in self._regions:
+            self._regions[region.contig] = []
+        self._regions[region.contig].append(region)
+
+    def add_regions(self, regions):
+        """
+        Add a list or iterable of regions to the collection.
+
+        Parameters:
+            regions (iterable): List of regions.
+        """
+        for r in regions:
+            self.add_region(r)

{reditools3-3.4 → reditools3-3.5}/reditools/rtchecks.py

@@ -47,28 +47,6 @@ class RTChecks(object):
             rtools=rtools,
         )
 
-    def check_splice_positions(self, rtools, bases):
-        """
-        Check if the contig and position are in a splice site.
-
-        Parameters:
-            rtools (REDItools): Object performing analysis
-            bases (CompiledPosition): Base position under analysis
-
-        Returns:
-            (bool): True if the position is not a splice site.
-        """
-        contig = bases.contig
-        if bases.position in rtools.splice_positions.get(contig, []):
-            rtools.log(
-                Logger.debug_level,
-                '[SPLICE_SITE] Discarding ({}, {}) because in splice site',
-                contig,
-                bases.position,
-            )
-            return False
-        return True
-
     def check_column_min_length(self, rtools, bases):
         """
         Check read depth.
@@ -210,13 +188,16 @@ class RTChecks(object):
         Returns:
             (bool): True if the position is in a target region
         """
-        if bases.position not in rtools.target_positions.get(bases.contig, []):
+        in_targets = rtools.target_regions.contains(
+            bases.contig,
+            bases.position,
+        )
+        if not in_targets:
             rtools.log(
                 Logger.debug_level,
-                'DISCARD COLUMN not in target positions',
+                'DISCARD COLUMN not in target regions',
             )
-            return False
-        return True
+        return in_targets
 
     def check_exclusions(self, bases, rtools):
         """
@@ -229,7 +210,11 @@ class RTChecks(object):
         Returns:
             (bool): True if the position is not excluded
         """
-        if bases.position in rtools.exclude_positions.get(bases.contig, []):
+        in_exclusions = rtools.exclude_regions.contains(
+            bases.contig,
+            bases.position,
+        )
+        if in_exclusions:
             rtools.log(Logger.debug_level, 'DISCARD COLUMN in excluded region')
             return False
         return True