telometer 0.75__tar.gz → 0.78__tar.gz

{telometer-0.75 → telometer-0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.75
+Version: 0.78
 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.75 → telometer-0.78}/setup.py

@@ -2,7 +2,7 @@ import setuptools
 
 setuptools.setup(
     name="telometer",
-    version="0.75",
+    version="0.78",
     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.75 → telometer-0.78}/telometer/telometer.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
-# Telometer v0.75
-# Created by: Santiago E Sanchez
-# Artandi Lab, Stanford University, 2023
+# Telometer v0.78
+# Created by: Santiago E Sanche8
+# Artandi Lab, Stanford University, 2024
 # Measures telomeres from ONT or PacBio long reads aligned to a T2T genome assembly
-# Simple Usage: telometer -b sorted_t2t.bam -o output.tsv
-
+# Simple Usage: telometer -b sorted_t2t.bam -o output.ts8
 import pysam
 import re
-import regex
+import regex as re
 import csv
 import argparse
 from multiprocessing import Pool, cpu_count
@@ -27,11 +26,11 @@ def get_adapters(chemistry):
     adapters_rc = [reverse_complement(adapter) for adapter in adapters]
     return adapters + adapters_rc
 
-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 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 find_initial_boundary_region(sequence, patterns, max_mismatches):
     """Finds the initial boundary region with allowed mismatches."""
@@ -39,65 +38,78 @@ 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 regex.finditer(f'({regex_pattern}){{e<={max_mismatches}}}', sequence, regex.BESTMATCH):
+    for match in re.finditer(f'({regex_pattern}){{e<={max_mismatches}}}', sequence, re.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, telomere_repeats_re, adapters, minreadlen = args
+    read_data, g_rich_telomere_pattern, c_rich_telomere_pattern, 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 = read_data['query_sequence']
+    seq_to_check = read_data['query_sequence']
 
     if read_data['is_reverse']:
         direction = "rev"
-        seq = reverse_complement(seq)
+        seq_to_check = reverse_complement(seq_to_check)
     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
 
-    if alignment_start < 15000 and "q" not in read_data['reference_name']:
-        arm = "p"
-    else:
-        arm = "q"
+    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)]
 
-    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
+    if telomere_starts:
+        telomere_start = telomere_starts[0]
 
-        telomere_end = min((seq.find(adapter) for adapter in adapters), default=-1)
-        if telomere_end == -1:
-            telomere_end = len(seq)
+        # 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_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_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))
 
-        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
+        # 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)
+    else:
+        telomere_start = None
+        telomere_end = None
+        telomere_length = 0
+        boundary_mm1_length = 0
+
+    result = {
+        'read_id': read_data['read_id'],
+        'telomere_start': telomere_start,
+        'telomere_end': telomere_end,
+        'telomere_length': telomere_length,
+        'boundary_mm1_length': boundary_mm1_length,
+        'chromosome': read_data['reference_name'],
+        'mapping_quality': read_data['mapping_quality'],
+        'direction': direction,
+        'arm': arm
+    }
+    return result
 
 def calculate_telomere_length():
     parser = argparse.ArgumentParser(description='Calculate telomere length from a BAM file.')
@@ -106,28 +118,27 @@ 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)
-    telomere_repeats = get_telomere_repeats()
-    telomere_repeats_re = "|".join(f'({repeat}){{2,}}' for repeat in telomere_repeats)
+    g_rich_telomere_pattern, c_rich_telomere_pattern = get_flexible_telomere_patterns()
 
+    bam_file = pysam.AlignmentFile(args.bam, "rb")
     read_data_list = [{
-        'query_name': read.query_name,
+        'read_id': 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)
-    } for read in bam_file]
+        'reference_length': bam_file.get_reference_length(read.reference_name) if read.reference_name is not None else None,
+        'is_reverse': read.is_reverse
+    } 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, telomere_repeats_re, adapters, args.minreadlen) for read_data in read_data_list]
+            [(read_data, g_rich_telomere_pattern, c_rich_telomere_pattern, adapters, args.minreadlen) for read_data in read_data_list]
         )
 
     results = [result for result in results if result]

{telometer-0.75 → telometer-0.78}/telometer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.75
+Version: 0.78
 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