telometer 0.80__tar.gz → 0.90__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.80
+Version: 0.90
 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.90}/setup.py

@@ -2,7 +2,7 @@ import setuptools
 
 setuptools.setup(
     name="telometer",
-    version="0.80",
+    version="0.90",
     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",
@@ -17,7 +17,7 @@ setuptools.setup(
     python_requires='>=3.7',
     entry_points={
         'console_scripts': [
-            'telometer=telometer:calculate_telomere_length',  # 'telometer' is the command, 'telometer:main' means the main function in telometer.py
+            'telometer=telometer:process_bam_file',  # 'telometer' is the command, 'telometer:main' means the main function in telometer.py
         ],
     },
 )

telometer-0.90/telometer/telometer.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+# Telometer v0.9
+# Created by: Santiago E Sanchez
+# 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
+
+import pysam
+import regex as re
+import pandas as pd
+import time
+from multiprocessing import Pool, cpu_count
+
+
+def reverse_complement(seq):
+    complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A', 'N': 'N'}
+    return "".join(complement[base] for base in reversed(seq))
+
+
+def get_telomere_repeats():
+    telomere_repeats = ['CCCTAA', 'TTAGGG']
+    telomere_repeats_rc = [reverse_complement(repeat) for repeat in telomere_repeats]
+    return telomere_repeats + telomere_repeats_rc
+
+
+def identify_telomere_regions(seq, telomere_motifs, window_size=100, step_size=10, density_threshold=0.1, max_gap_length=50):
+    telomere_regions = []
+    current_start = None
+    gap_length = 0
+    has_large_gap = False
+    densities = []
+
+    combined_motif_pattern = '|'.join(f'({motif})' for motif in telomere_motifs)
+
+    for i in range(0, len(seq) - window_size + 1, step_size):
+        window_seq = seq[i:i + window_size]
+        motif_count = len(re.findall(combined_motif_pattern, window_seq))
+        density = motif_count / (window_size / len(telomere_motifs[0]))  # Assuming all motifs have similar lengths
+        densities.append(density)
+
+        if density >= density_threshold:
+            if current_start is None:
+                current_start = i
+            gap_length = 0
+        else:
+            if current_start is not None:
+                gap_length += step_size
+                if gap_length > max_gap_length:
+
+                    mismatch_motif_count = len(re.findall(f"({combined_motif_pattern}){{e<=1}}", window_seq))
+                    mismatch_density = mismatch_motif_count / (window_size / len(telomere_motifs[0]))
+
+                    if mismatch_density >= density_threshold:
+
+                        gap_length = 0
+                    else:
+                        has_large_gap = True
+                        telomere_regions.append((current_start, i - gap_length + step_size))
+                        current_start = None
+                        gap_length = 0
+
+    if current_start is not None:
+        telomere_regions.append((current_start, len(seq)))
+
+    return telomere_regions, densities, has_large_gap, combined_motif_pattern
+
+
+def measure_telomere_length(seq, telomere_motifs, window_size=100, step_size=10, density_threshold=0.1, max_gap_length=50):
+    telomere_regions, densities, has_large_gap, combined_motif_pattern = identify_telomere_regions(seq, telomere_motifs, window_size, step_size, density_threshold, max_gap_length)
+
+    if not telomere_regions:
+        return 0, 0, 0, densities, has_large_gap, combined_motif_pattern
+
+
+    terminus_regions = []
+    for start, end in telomere_regions:
+        if start < 100 or end > len(seq) - 100:
+            terminus_regions.append((start, end))
+
+    if not terminus_regions:
+        return 0, 0, 0, densities, has_large_gap, combined_motif_pattern
+
+
+    telomere_start, telomere_end = terminus_regions[0]
+    telomere_length = telomere_end - telomere_start
+
+    return telomere_start, telomere_end, telomere_length, densities, has_large_gap, combined_motif_pattern
+
+
+def process_read(read_data, telomere_motifs, max_gap_length, min_read_len):
+    if read_data['is_unmapped'] or read_data['reference_name'] == 'chrM':
+        return None
+
+    if read_data['reference_start'] > 30000 and read_data['reference_end'] < read_data['reference_length'] - 30000:
+        return None
+
+    seq = read_data['query_sequence']
+    if seq is None or len(seq) < min_read_len:
+        return None
+
+
+    alignment_start = read_data['reference_start']
+    alignment_end = read_data['reference_end']
+    reference_genome_length = read_data['reference_length']
+
+    if alignment_start < 15000 and alignment_end <= reference_genome_length - 30000:
+        arm = "p"
+    else:
+        arm = "q"
+
+    direction = "rev" if read_data['is_reverse'] else "fwd"
+
+
+    telomere_start, telomere_end, telomere_length, densities, has_large_gap, combined_motif_pattern = measure_telomere_length(seq, telomere_motifs, max_gap_length=max_gap_length)
+    if telomere_length < 1:
+        return None
+    return {
+        'chromosome': read_data['reference_name'],
+        'reference_start': alignment_start,
+        'reference_end': alignment_end,
+        'telomere_length': telomere_length,
+        #'subtel_boundary_length': telomere_end - telomere_start,
+        'read_id': read_data['query_name'],
+        'mapping_quality': read_data['mapping_quality'],
+        'read_length': len(seq),
+        'arm': arm,
+        'direction': direction
+        #'has_large_gap': has_large_gap
+    }
+
+
+def process_read_wrapper(args):
+    return process_read(*args)
+
+
+def process_bam_file(bam_file_path, output_file_path, max_gap_length=100, min_read_len=1000, num_processes=8):
+    start_time = time.time()
+
+
+    bam_file = pysam.AlignmentFile(bam_file_path, "rb")
+
+    telomere_motifs = get_telomere_repeats()
+
+    results = []
+    read_results = {}
+    total_reads = 0
+    large_gap_count = 0
+
+
+    read_data_list = [{
+        '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
+    } for read in bam_file if read.reference_name is not None and read.reference_name != 'chrM']
+
+    # Use multiprocessing Pool for parallel processing
+    with Pool(processes=num_processes) as pool:
+        for result in pool.imap_unordered(process_read_wrapper, [(rd, telomere_motifs, max_gap_length, min_read_len) for rd in read_data_list]):
+            if result:
+                total_reads += 1
+                #if result['has_large_gap']:
+                #    large_gap_count += 1
+
+                # Check for existing results with the same read_id
+                existing_result = read_results.get(result['read_id'])
+                if existing_result:
+                    if (result['mapping_quality'] > existing_result['mapping_quality'] or
+                        (result['mapping_quality'] == existing_result['mapping_quality'] and
+                         result['telomere_length'] > existing_result['telomere_length'])):
+                        read_results[result['read_id']] = result
+                else:
+                    read_results[result['read_id']] = result
+
+    bam_file.close()
+
+    # Convert results to a DataFrame and save to a TSV file
+    results_df = pd.DataFrame(list(read_results.values()))
+    results_df.to_csv(output_file_path, sep='\t', index=False)
+
+    # Calculate and print the percentage of telomeres with gaps larger than max_gap_length
+    #if total_reads > 0:
+    #    large_gap_percentage = (large_gap_count / total_reads) * 100
+    #else:
+    #    large_gap_percentage = 0
+
+    print(f"Telometer completed successfully. Total telomeres measured: {len(read_results)}")
+    print(f"Total processing time: {time.time() - start_time:.2f} seconds")
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Calculate telomere length from a BAM file.')
+    parser.add_argument('-b', '--bam', help='The path to the sorted BAM file.', required=True)
+    parser.add_argument('-o', '--output', help='The path to the output file.', required=True)
+    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)
+    parser.add_argument('-g', '--maxgaplen', default=100, type=int, help='Maximum allowed gap length between telomere regions. Optional', required=False)
+    parser.add_argument('-t', '--threads', default=cpu_count(), type=int, help='Number of processing threads to use. Optional', required=False)
+
+    args = parser.parse_args()
+
+    process_bam_file(args.bam, args.output, max_gap_length=args.maxgaplen, min_read_len=args.minreadlen, num_processes=args.threads)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telometer
-Version: 0.80
+Version: 0.90
 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.90/telometer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+telometer = telometer:process_bam_file

telometer-0.80/telometer/telometer.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python3
-# Telometer v0.79
-# 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.ts8
-import pysam
-import re
-import regex as re
-import csv
-import argparse
-from multiprocessing import Pool, cpu_count
-
-def reverse_complement(seq):
-    """Returns the reverse complement of a DNA sequence."""
-    complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A', 'N': 'N'}
-    return "".join(complement[base] for base in reversed(seq))
-
-def get_adapters(chemistry):
-    """Returns the adapter sequences based on the sequencing chemistry."""
-    if chemistry == 'r10':
-        adapters = ['TTTTTTTTCCTGTACTTCGTTCAGTTACGTATTGCT', 'GCAATACGTAACTGAACGAAGTACAGG']
-    else:
-        adapters = ['TTTTTTTTTTTAATGTACTTCGTTCAGTTACGTATTGCT', 'GCAATACGTAACTGAACGAAGT']
-
-    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 find_initial_boundary_region(sequence, patterns, max_mismatches):
-    """Finds the initial boundary region with allowed mismatches."""
-    boundary_length = 0
-    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):
-        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
-
-    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']
-
-    if read_data['is_reverse']:
-        direction = "rev"
-        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
-
-    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]
-
-        # 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_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
-
-
-def calculate_telomere_length():
-    parser = argparse.ArgumentParser(description='Calculate telomere length from a BAM file.')
-    parser.add_argument('-b', '--bam', help='The path to the sorted BAM file.', required=True)
-    parser.add_argument('-o', '--output', help='The path to the output file.', required=True)
-    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()
-
-    adapters = get_adapters(args.chemistry)
-    g_rich_telomere_pattern, c_rich_telomere_pattern = get_flexible_telomere_patterns()
-
-    bam_file = pysam.AlignmentFile(args.bam, "rb")
-    read_data_list = [{
-        'read_id': read.query_name,
-        'is_unmapped': read.is_unmapped,
-        '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
-    } 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]
-        )
-
-    results = [result for result in results if result]
-
-    # Ensure only the best result per read_id is saved
-    best_results = {}
-    for result in results:
-        read_id = result['read_id']
-        if read_id not in best_results:
-            best_results[read_id] = result
-        else:
-            existing_result = best_results[read_id]
-            if result['mapping_quality'] > existing_result['mapping_quality']:
-                best_results[read_id] = result
-            elif result['mapping_quality'] == existing_result['mapping_quality']:
-                if result['telomere_length'] > existing_result['telomere_length']:
-                    best_results[read_id] = result
-                elif result['telomere_length'] == existing_result['telomere_length']:
-                    # Arbitrarily keep the existing one if both telomere_length and mapping_quality are the same
-                    pass
-
-    final_results = list(best_results.values())
-
-    if final_results:
-        with open(args.output, 'w', newline='') as output_file:
-            writer = csv.DictWriter(output_file, fieldnames=final_results[0].keys(), delimiter='\t')
-            writer.writeheader()
-            writer.writerows(final_results)
-
-    print(f"Telometer completed successfully. Total telomeres measured: {len(final_results)}")
-
-if __name__ == "__main__":
-    calculate_telomere_length()

telometer-0.80/telometer.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-telometer = telometer:calculate_telomere_length