telometer 0.80__tar.gz → 0.81__tar.gz

{telometer-0.80 → telometer-0.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.80
+Version: 0.81
 Summary: a simple regular expression based method for measuring individual, chromosome-specific telomere lengths from long-read sequencing data
 Author: Santiago E Sanchez
 Author-email: ses94@stanford.edu

{telometer-0.80 → telometer-0.81}/setup.py

@@ -2,7 +2,7 @@ import setuptools
 
 setuptools.setup(
     name="telometer",
-    version="0.80",
+    version="0.81",
     author="Santiago E Sanchez",
     author_email="ses94@stanford.edu",
     description="a simple regular expression based method for measuring individual, chromosome-specific telomere lengths from long-read sequencing data",

{telometer-0.80 → telometer-0.81}/telometer/telometer.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
-# Telometer v0.79
-# Created by: Santiago E Sanche8
-# Artandi Lab, Stanford University, 2024
+# Telometer v0.81
+# Created by: Santiago E Sanchez
+# Artandi Lab, Stanford University, 2023
 # Measures telomeres from ONT or PacBio long reads aligned to a T2T genome assembly
-# Simple Usage: telometer -b sorted_t2t.bam -o output.ts8
+# Simple Usage: telometer -b sorted_t2t.bam -o output.tsv
+
 import pysam
 import re
-import regex as re
+import regex
 import csv
 import argparse
 from multiprocessing import Pool, cpu_count
@@ -26,11 +27,11 @@ def get_adapters(chemistry):
     adapters_rc = [reverse_complement(adapter) for adapter in adapters]
     return adapters + adapters_rc
 
-def get_flexible_telomere_patterns():
-    """Returns flexible telomere repeat patterns for both G-rich and C-rich strands."""
-    g_rich_telomere_pattern = r'(T{1,2}T{1,2}A{1,2}G{1,2}G{1,2}G{1,2}){2,}'
-    c_rich_telomere_pattern = r'(C{1,2}C{1,2}C{1,2}T{1,2}A{1,2}A{1,2}){2,}'
-    return g_rich_telomere_pattern, c_rich_telomere_pattern
+def get_telomere_repeats():
+    """Returns the telomere repeat sequences."""
+    telomere_repeats = ['GGCCA', 'CCCTAA', 'TTAGGG', 'CCCTGG', 'CTTCTT', 'TTAAAA', 'CCTGG']
+    telomere_repeats_rc = [reverse_complement(repeat) for repeat in telomere_repeats]
+    return telomere_repeats + telomere_repeats_rc
 
 def find_initial_boundary_region(sequence, patterns, max_mismatches):
     """Finds the initial boundary region with allowed mismatches."""
@@ -38,75 +39,65 @@ def find_initial_boundary_region(sequence, patterns, max_mismatches):
     combined_pattern = '|'.join(f'({pattern})' for pattern in patterns)
     regex_pattern = f'({combined_pattern}){{2,}}'
 
-    for match in re.finditer(f'({regex_pattern}){{e<={max_mismatches}}}', sequence, re.BESTMATCH):
+    for match in regex.finditer(f'({regex_pattern}){{e<={max_mismatches}}}', sequence, regex.BESTMATCH):
         boundary_length = max(boundary_length, len(match.group(0)))
     return boundary_length
 
-def determine_arm(reference_name, alignment_start, reference_length):
-    """Determine the chromosome arm based on the alignment start position and reference name."""
-    if alignment_start < 15000 and "q" not in reference_name:
-        return "p"
-    return "q"
-
 def process_read(args):
-    read_data, g_rich_telomere_pattern, c_rich_telomere_pattern, adapters, minreadlen = args
+    read_data, telomere_repeats_re, adapters, minreadlen = args
 
     if read_data['is_unmapped'] or read_data['query_sequence'] is None or len(read_data['query_sequence']) < minreadlen:
-        print(f"Skipping read {read_data['read_id']}: unmapped or too short")
         return None
 
     alignment_start = read_data['reference_start']
     alignment_end = read_data['reference_end']
-    seq_to_check = read_data['query_sequence']
+    seq = read_data['query_sequence']
 
     if read_data['is_reverse']:
         direction = "rev"
-        seq_to_check = reverse_complement(seq_to_check)
+        seq = reverse_complement(seq)
     else:
         direction = "fwd"
 
     reference_genome_length = read_data['reference_length']
+
     if alignment_start >= 15000 and alignment_start <= reference_genome_length - 30000:
-        print(f"Skipping read {read_data['read_id']}: alignment start {alignment_start} within filtered range")
         return None
 
-    arm = determine_arm(read_data['reference_name'], alignment_start, reference_genome_length)
-
-    telomere_starts = [m.start() for m in re.finditer(g_rich_telomere_pattern, seq_to_check)]
-    if not telomere_starts:
-        telomere_starts = [m.start() for m in re.finditer(c_rich_telomere_pattern, seq_to_check)]
-
-    if telomere_starts:
-        telomere_start = telomere_starts[0]
+    if alignment_start < 15000 and "q" not in read_data['reference_name']:
+        arm = "p"
+    else:
+        arm = "q"
 
-        # Find the end of the telomere region
-        telomere_end = min((pos for pos in (seq_to_check.find(adapter) for adapter in adapters) if pos != -1), default=len(seq_to_check))
+    telomere_start = [m.start() for m in re.finditer(telomere_repeats_re, seq)]
+    if telomere_start:
+        telomere_start = telomere_start[0]
+        if telomere_start > 100 and (len(seq) - telomere_start > 200):
+            return None
 
-        telomere_region = seq_to_check[telomere_start:telomere_end]
-        telomere_repeat = [m.group() for m in re.finditer(g_rich_telomere_pattern, telomere_region)]
-        if not telomere_repeat:
-            telomere_repeat = [m.group() for m in re.finditer(c_rich_telomere_pattern, telomere_region)]
+        telomere_end = min((seq.find(adapter) for adapter in adapters), default=-1)
+        if telomere_end == -1:
+            telomere_end = len(seq)
 
+        telomere_region = seq[telomere_start:telomere_end]
+        telomere_repeat = [m.group() for m in re.finditer('|'.join(telomere_repeats_re.split('|')), telomere_region)]
         telomere_length = len(''.join(telomere_repeat))
-        if telomere_length > 0:
-        # Find the region immediately adjacent to the telomere region
-            boundary_mm1_region = seq_to_check[telomere_end:]
-            boundary_mm1_length = find_initial_boundary_region(boundary_mm1_region, g_rich_telomere_pattern.split('|') + c_rich_telomere_pattern.split('|'), max_mismatches=2)
-            result = {
-                'chromosome': read_data['reference_name'],
-                'arm': arm,
-                'telomere_start': telomere_start,
-                'telomere_end': telomere_end,
-                'telomere_length': telomere_length,
-                'subtel_boundary_length': boundary_mm1_length,
-                'read_id': read_data['read_id'],
-                'mapping_quality': read_data['mapping_quality'],
-                'direction': direction
-            }
-            return result
-        else:
-            return None
 
+        boundary_mm1_length = find_initial_boundary_region(telomere_region, telomere_repeats_re.split('|'), max_mismatches=1)
+
+        return {
+            'chromosome': read_data['reference_name'],
+            'reference_start': alignment_start,
+            'reference_end': alignment_end,
+            'telomere_length': telomere_length,
+            'subtel_boundary_length': boundary_mm1_length,
+            'read_id': read_data['query_name'],
+            'mapping_quality': read_data['mapping_quality'],
+            'read_length': len(seq),
+            'arm': arm,
+            'direction': direction
+        }
+    return None
 
 def calculate_telomere_length():
     parser = argparse.ArgumentParser(description='Calculate telomere length from a BAM file.')
@@ -115,27 +106,28 @@ def calculate_telomere_length():
     parser.add_argument('-c', '--chemistry', default="r10", help="Sequencing chemistry (r9 or r10, default=r10). Optional", required=False)
     parser.add_argument('-m', '--minreadlen', default=1000, type=int, help='Minimum read length to consider (Default: 1000 for telomere capture, use 4000 for WGS). Optional', required=False)
     args = parser.parse_args()
+    bam_file = pysam.AlignmentFile(args.bam, "rb")
 
     adapters = get_adapters(args.chemistry)
-    g_rich_telomere_pattern, c_rich_telomere_pattern = get_flexible_telomere_patterns()
+    telomere_repeats = get_telomere_repeats()
+    telomere_repeats_re = "|".join(f'({repeat}){{2,}}' for repeat in telomere_repeats)
 
-    bam_file = pysam.AlignmentFile(args.bam, "rb")
     read_data_list = [{
-        'read_id': read.query_name,
+        'query_name': read.query_name,
         'is_unmapped': read.is_unmapped,
+        'is_reverse': read.is_reverse,
         'reference_start': read.reference_start,
         'reference_end': read.reference_end,
         'reference_name': read.reference_name,
         'mapping_quality': read.mapping_quality,
         'query_sequence': read.query_sequence,
-        'reference_length': bam_file.get_reference_length(read.reference_name) if read.reference_name is not None else None,
-        'is_reverse': read.is_reverse
+        'reference_length': bam_file.get_reference_length(read.reference_name) if read.reference_name is not None else None
     } for read in bam_file if read.reference_name is not None and read.reference_name != 'chrM']
 
     with Pool(processes=cpu_count()) as pool:
         results = pool.map(
             process_read,
-            [(read_data, g_rich_telomere_pattern, c_rich_telomere_pattern, adapters, args.minreadlen) for read_data in read_data_list]
+            [(read_data, telomere_repeats_re, adapters, args.minreadlen) for read_data in read_data_list]
         )
 
     results = [result for result in results if result]

{telometer-0.80 → telometer-0.81}/telometer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.80
+Version: 0.81
 Summary: a simple regular expression based method for measuring individual, chromosome-specific telomere lengths from long-read sequencing data
 Author: Santiago E Sanchez
 Author-email: ses94@stanford.edu