telometer 1.0__tar.gz → 1.1__tar.gz

{telometer-1.0 → telometer-1.1}/PKG-INFO

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

@@ -2,7 +2,7 @@ import setuptools
 
 setuptools.setup(
     name="telometer",
-    version="1.0",
+    version="1.01",
     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-1.0 → telometer-1.1}/telometer/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.0'
+__version__ = '1.01'
 __author__ = 'Santiago E Sanchez'
 __email__ = 'santy.esanchez@gmail.com'
 __license__ = 'MIT'

{telometer-1.0 → telometer-1.1}/telometer/telometer.py

@@ -24,9 +24,8 @@ def get_telomere_repeats():
     telomere_repeats_rc = [reverse_complement(repeat) for repeat in telomere_repeats]
     return telomere_repeats + telomere_repeats_rc
 
-
 def identify_telomere_regions(seq, base_qualities, telomere_motifs, window_size=120, step_size=12,
-                              density_threshold=0.1, max_gap_length=250, quality_threshold=15):
+                              density_threshold=0.1, max_gap_length=20, quality_threshold=15):
     telomere_regions = []
     current_start = None
     gap_length = 0
@@ -38,7 +37,7 @@ def identify_telomere_regions(seq, base_qualities, telomere_motifs, window_size=
     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
+        density = motif_count / (window_size / len(telomere_motifs[0]))
         densities.append(density)
 
         if density >= density_threshold:
@@ -49,7 +48,6 @@ def identify_telomere_regions(seq, base_qualities, telomere_motifs, window_size=
             if current_start is not None:
                 gap_length += step_size
 
-
                 gap_start = i - gap_length
                 gap_end = i
                 gap_quality = base_qualities[gap_start:gap_end]
@@ -59,19 +57,15 @@ def identify_telomere_regions(seq, base_qualities, telomere_motifs, window_size=
                 else:
                     avg_gap_quality = 0
 
-
                 if avg_gap_quality < quality_threshold:
                     gap_length = 0
                     continue
 
-
                 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
@@ -84,28 +78,20 @@ def identify_telomere_regions(seq, base_qualities, telomere_motifs, window_size=
 
     return telomere_regions, densities, has_large_gap, combined_motif_pattern
 
-
 def detect_discontinuities(base_qualities, window_length=11, polyorder=2, gradient_threshold=-1):
-
     if len(base_qualities) < window_length:
-        window_length = len(base_qualities) if len(base_qualities) % 2 == 1 else len(base_qualities) - 1  # Window length must be odd
-
+        window_length = len(base_qualities) if len(base_qualities) % 2 == 1 else len(base_qualities) - 1
 
     if len(base_qualities) > polyorder:
         smoothed_qualities = savgol_filter(base_qualities, window_length=window_length, polyorder=polyorder)
     else:
-
         smoothed_qualities = base_qualities
 
-
     gradient = np.diff(smoothed_qualities)
-
-
     discontinuities = np.where(gradient < gradient_threshold)[0]
 
     return discontinuities, smoothed_qualities
 
-
 def check_gap(seq, base_qualities, telomere_regions, gradient_threshold=-1, quality_threshold=15):
     merged_regions = []
     prev_end = None
@@ -129,24 +115,37 @@ def check_gap(seq, base_qualities, telomere_regions, gradient_threshold=-1, qual
 
     return merged_regions
 
-def measure_telomere_length(seq, telomere_motifs, base_qualities, window_size=120, step_size=12, density_threshold=0.1, max_gap_length=150, quality_threshold=15):
+def measure_telomere_length(seq, telomere_motifs, base_qualities, window_size=120, step_size=12,
+                                         density_threshold=0.1, max_gap_length=20, quality_threshold=15):
+
     telomere_regions, densities, has_large_gap, combined_motif_pattern = identify_telomere_regions(
         seq, base_qualities, telomere_motifs, window_size, step_size, density_threshold, max_gap_length, quality_threshold)
 
     if not telomere_regions:
         return 0, 0, 0, densities, has_large_gap, combined_motif_pattern
 
+
+    if not any(density >= 0.75 for density in densities):
+        return 0, 0, 0, densities, has_large_gap, combined_motif_pattern
+
+
     merged_telomere_regions = check_gap(seq, base_qualities, telomere_regions, gradient_threshold=-1, quality_threshold=quality_threshold)
-    terminus_regions = [region for region in merged_telomere_regions if region[0] < 100 or region[1] > len(seq) - 100]
+
+    terminus_regions = []
+    for start, end in merged_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
 
-# New function to process a single read
+
 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
@@ -155,7 +154,7 @@ def process_read(read_data, telomere_motifs, max_gap_length, min_read_len):
         return None
 
     seq = read_data['query_sequence']
-    base_qualities = read_data['query_qualities']  # Extract base qualities here
+    base_qualities = read_data['query_qualities']
     if seq is None or len(seq) < min_read_len:
         return None
 
@@ -170,13 +169,15 @@ def process_read(read_data, telomere_motifs, max_gap_length, min_read_len):
 
     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, base_qualities, max_gap_length=max_gap_length)
 
     if telomere_length < 1:
         return None
 
+    if (telomere_length + 50) > len(seq):
+        return None
+
     return {
         'chromosome': read_data['reference_name'],
         'reference_start': alignment_start,
@@ -189,7 +190,6 @@ def process_read(read_data, telomere_motifs, max_gap_length, min_read_len):
         'direction': direction
     }
 
-
 def process_read_wrapper(args):
     return process_read(*args)
 
@@ -205,8 +205,7 @@ def estimate_memory_usage(reads_list):
         memory_usage += sys.getsizeof(read['query_name']) + seq_len + quality_len + sys.getsizeof(read)
     return memory_usage
 
-
-def process_bam_file(bam_file_path, output_file_path, max_gap_length=150, min_read_len=1000, num_processes=8, memory_limit_gb=8):
+def process_bam_file(bam_file_path, output_file_path, max_gap_length=20, min_read_len=1000, num_processes=8, memory_limit_gb=8):
     start_time = time.time()
     bam_file = pysam.AlignmentFile(bam_file_path, "rb")
     telomere_motifs = get_telomere_repeats()
@@ -239,30 +238,39 @@ def process_bam_file(bam_file_path, output_file_path, max_gap_length=150, min_re
 
     for read in bam_file:
         if read.reference_name is not None and read.reference_name != 'chrM':
-            read_data = {
-                '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,
-                'query_qualities': read.query_qualities,
-                'reference_length': bam_file.get_reference_length(read.reference_name) if read.reference_name is not None else None
-            }
-
-
-            read_memory = estimate_memory_usage([read_data])
-            batch_memory += read_memory
-            batch.append(read_data)
-
-
-            if batch_memory >= memory_limit_bytes:
-                print(f"Processing batch of {len(batch)} reads, approx memory used: {batch_memory / (1024 ** 3):.2f} GB")
-                process_batch(batch)
-                batch_memory = 0
-
+            base_qualities = read.query_qualities
+
+            if base_qualities is not None and len(base_qualities) > 0:
+                avg_phred_score = sum(base_qualities) / len(base_qualities)
+            else:
+                avg_phred_score = 0
+                #print("no phred score")
+
+            if avg_phred_score > 9:
+                read_data = {
+                    '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,
+                    'query_qualities': base_qualities,
+                    'reference_length': bam_file.get_reference_length(read.reference_name) if read.reference_name is not None else None
+                }
+
+                read_memory = estimate_memory_usage([read_data])
+                batch_memory += read_memory
+                batch.append(read_data)
+
+                if batch_memory >= memory_limit_bytes:
+                    print(f"Processing batch of {len(batch)} reads, approx memory used: {batch_memory / (1024 ** 3):.2f} GB")
+                    process_batch(batch)
+                    batch_memory = 0
+                    batch = []
+            #else:
+                #print("low phred")
 
     if batch:
         print(f"Processing final batch of {len(batch)} reads")
@@ -270,12 +278,36 @@ def process_bam_file(bam_file_path, output_file_path, max_gap_length=150, min_re
 
     bam_file.close()
 
-
     results_df = pd.DataFrame(list(read_results.values()))
     results_df.to_csv(output_file_path, sep='\t', index=False)
 
     print(f"Telometer completed successfully. Total telomeres measured: {len(read_results)}")
     print(f"Total processing time: {time.time() - start_time:.2f} seconds")
+    # After the final print statements
+    if len(read_results) > 0:
+        # Convert read results to a DataFrame for easy statistical computation
+        results_df = pd.DataFrame(list(read_results.values()))
+
+        # Calculate summary statistics for the 'telomere_length' column
+        telomere_lengths = results_df['telomere_length']
+
+        min_length = telomere_lengths.min()
+        percentile_25 = telomere_lengths.quantile(0.25)
+        median_length = telomere_lengths.median()
+        mean_length = telomere_lengths.mean()
+        percentile_75 = telomere_lengths.quantile(0.75)
+        max_length = telomere_lengths.max()
+
+        # Print summary statistics
+        print("\nTelomere Length Summary Statistics:")
+        print(f"Min: {min_length:.2f}")
+        print(f"25th Percentile: {percentile_25:.2f}")
+        print(f"Median: {median_length:.2f}")
+        print(f"Mean: {mean_length:.2f}")
+        print(f"75th Percentile: {percentile_75:.2f}")
+        print(f"Max: {max_length:.2f}")
+    else:
+        print("No telomere measurements to summarize.")
 
 
 def run_telometer():
@@ -283,10 +315,11 @@ def run_telometer():
     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=250, type=int, help='Maximum allowed gap length between telomere regions. Optional', required=False)
+    parser.add_argument('-g', '--maxgaplen', default=20, 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)
+    parser.add_argument('-l', '--memlimit', default=8, type=int, help="Maximum amount of memory to commit per batch of reads while processing. Optional, default = 8 Gb", 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)
+    process_bam_file(args.bam, args.output, max_gap_length=args.maxgaplen, min_read_len=args.minreadlen, num_processes=args.threads, memory_limit_gb=args.memlimit)
 
 if __name__ == "__main__":
     run_telometer()

{telometer-1.0 → telometer-1.1}/telometer.egg-info/PKG-INFO

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