strkit 0.8.0a5__tar.gz → 0.8.0a7__tar.gz

{strkit-0.8.0a5/strkit.egg-info → strkit-0.8.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strkit
-Version: 0.8.0a5
+Version: 0.8.0a7
 Summary: A toolkit for analyzing variation in short(ish) tandem repeats.
 Home-page: https://github.com/davidlougheed/strkit
 Author: David Lougheed

strkit-0.8.0a7/strkit/VERSION

@@ -0,0 +1 @@
+0.8.0a7

{strkit-0.8.0a5 → strkit-0.8.0a7}/strkit/call/caller/call_locus.py

@@ -310,8 +310,10 @@ def call_alleles_with_incorporated_snvs(
         ws = ws / np.sum(ws)
         c_ws.append(ws)
 
-    cdd: list[Optional[CallDict]] = [
-        call_alleles(
+    cdd: list[CallDict] = []
+
+    for ci in cluster_indices:
+        cc: Optional[CallDict] = call_alleles(
             cns[ci], (),  # Don't bother separating by strand for now...
             c_ws[ci], (),
             bootstrap_iterations=num_bootstrap // n_alleles,  # Apportion the bootstrap iters across alleles
@@ -327,16 +329,14 @@ def call_alleles_with_incorporated_snvs(
             logger_=logger_,
             debug_str=f"{locus_log_str} a{ci}"
         )
-        for ci in cluster_indices
-    ]
 
-    if any((cd is None) for cd in cdd):
-        # One of the calls could not be made... what to do?
-        # TODO: !!!!
-        #  For now, revert to dist
-        return "dist", None
+        if cc is None:  # Early escape
+            # One of the calls could not be made... what to do?
+            # TODO: !!!!
+            #  For now, revert to dist
+            return "dist", None
 
-    # Otherwise, cdd is confirmed list[CallDict] - no Nones
+        cdd.append(cc)
 
     # TODO: Multi-allele phasing across STRs
 
@@ -409,10 +409,11 @@ def call_locus(
     left_flank_coord = left_coord - flank_size
     right_flank_coord = right_coord + flank_size
 
-    ref_left_flank_seq = ""
-    ref_right_flank_seq = ""
-    ref_seq = ""
-    raised = False
+    ref_left_flank_seq: str = ""
+    ref_right_flank_seq: str = ""
+    ref_right_flank_seq_plus_1: str = ""
+    ref_seq: str = ""
+    raised: bool = False
 
     n_alleles: Optional[int] = get_n_alleles(2, sex_chroms, contig)
     if n_alleles is None:  # Sex chromosome, but we don't have a specified sex chromosome karyotype
@@ -424,7 +425,9 @@ def call_locus(
 
     try:
         ref_left_flank_seq = ref.fetch(ref_contig, left_flank_coord, left_coord)
-        ref_right_flank_seq = ref.fetch(ref_contig, right_coord, right_flank_coord)
+        ref_right_flank_seq_plus_1 = ref.fetch(ref_contig, right_coord, right_flank_coord + 1)
+        # ref_right_flank_seq = ref.fetch(ref_contig, right_coord, right_flank_coord)
+        ref_right_flank_seq = ref_right_flank_seq_plus_1[:-1]
         ref_seq = ref.fetch(ref_contig, left_coord, right_coord)
     except IndexError:
         logger_.warning(
@@ -477,32 +480,6 @@ def call_locus(
 
     n_overlapping_reads = len(overlapping_segments)
 
-    call_dict_base = {
-        "locus_index": t_idx,
-        "contig": contig,
-        "start": left_coord,
-        "end": right_coord,
-        **({} if respect_ref else {
-            "start_adj": left_coord_adj,
-            "end_adj": right_coord_adj,
-        }),
-        "motif": motif,
-        "ref_cn": ref_cn,
-    }
-
-    # Check now if we definitely don't have enough reads to make a call
-    # We also check again later when we calculate all the flanking stuff
-    if n_overlapping_reads < min_reads:
-        return {
-            **call_dict_base,
-            "call": None,
-            "call_95_cis": None,
-            "call_99_cis": None,
-            "peaks": None,
-            "read_peaks_called": False,
-            "time": (datetime.now() - call_timer).total_seconds(),
-        }
-
     sorted_read_lengths = np.sort(read_lengths)
 
     # Build the read dictionary with segment information, copy number, weight, & more. ---------------------------------
@@ -515,11 +492,20 @@ def call_locus(
 
     read_pairs: dict[str, list] = {}
 
+    # Keep track of left-most and right-most coordinates
+    # If SNV-based peak calling is enabled, we can use this to pre-fetch reference data for all reads to reduce the
+    # fairly significant overhead involved in reading from the reference genome for each read to identifify SNVs.
+    left_most_coord: int = 99999999999999
+    right_most_coord: int = 0
+
     for segment, read_len in zip(overlapping_segments, read_lengths):
         rn = segment.query_name
         segment_start = segment.reference_start
         segment_end = segment.reference_end
 
+        left_most_coord = min(left_most_coord, segment_start)
+        right_most_coord = max(right_most_coord, segment_end)
+
         # While .query_sequence is Optional[str], we know (because we skipped all segments with query_sequence is None
         # above) that this is guaranteed to be, in fact, not None.
         qs: str = segment.query_sequence
@@ -529,14 +515,14 @@ def call_locus(
 
         fqqs: Optional[list[int]] = segment.query_qualities
 
-        realigned = False
+        realigned: bool = False
         pairs = None
 
         # Soft-clipping in large insertions can result from mapping difficulties.
         # If we have a soft clip which overlaps with our TR region (+ flank), we can try to recover it
         # via realignment with parasail.
         # 4: BAM code for soft clip
-        # TODO: if some of the BAM alignment is present, use it to reduce realignment overhead?
+        # TODO: if some alignment is present, use it to reduce realignment overhead?
         #  - use start point + flank*3 or end point - flank*3 or something like that
         if realign and (force_realign or (
             (c1[0] == 4 and segment_start > left_flank_coord >= segment_start - c1[1]) or
@@ -548,7 +534,7 @@ def call_locus(
             q = mp.Queue()
             proc = mp.Process(target=realign_read, kwargs=dict(
                 # fetch an extra base for the right flank coordinate check later (needs to be >= the exclusive coord)
-                ref_seq=ref_left_flank_seq + ref_seq + ref.fetch(ref_contig, right_coord, right_flank_coord + 1),
+                ref_seq=ref_left_flank_seq + ref_seq + ref_right_flank_seq_plus_1,  # TODO: plus 1, really?
                 query_seq=calculate_seq_with_wildcards(qs, fqqs),
                 left_flank_coord=left_flank_coord,
                 flank_size=flank_size,
@@ -659,6 +645,8 @@ def call_locus(
 
         crs_cir = chimeric_read_status[rn] == 3  # Chimera within the TR region, indicating a potential large expansion
         read_dict[rn] = {
+            "_ref_start": segment_start,
+            "_ref_end": segment_end,
             "s": "-" if segment.is_reverse else "+",
             "cn": read_cn,
             "w": read_weight,
@@ -670,18 +658,29 @@ def call_locus(
         # Reads can show up more than once - TODO - cache this information across loci
 
         if should_incorporate_snvs:
-            snvs = get_read_snvs(qs, pairs, contig, ref, left_coord_adj, right_coord_adj)
-            locus_snvs.update(snvs.keys())
-            read_dict[rn]["snv"] = snvs
+            # Store the segment sequence in the read dict for the next go-around if we've enabled SNV incorporation,
+            # in order to pass the query sequence to the get_read_snvs function with the cached ref string.
+            read_dict[rn]["_qs"] = qs
 
-    # End of read loop ----–----–----–----–----–----–----–----–----–----–----–----–----–----–----–----–----–----–----–--
+    # End of first read loop -------------------------------------------------------------------------------------------
 
     n_reads_in_dict: int = len(read_dict)
 
-    # Have read dict now, so add it to the base call information dictionary
-    call_dict_base["reads"] = read_dict
+    call_dict_base = {
+        "locus_index": t_idx,
+        "contig": contig,
+        "start": left_coord,
+        "end": right_coord,
+        **({} if respect_ref else {
+            "start_adj": left_coord_adj,
+            "end_adj": right_coord_adj,
+        }),
+        "motif": motif,
+        "ref_cn": ref_cn,
+        "reads": read_dict,
+    }
 
-    # Check again if we don't have enough reads to make a call, now that we've maybe filtered a few more out.
+    # Check now if we don't have enough reads to make a call. We can still return some read-level information!
     if n_reads_in_dict < min_reads:
         return {
             **call_dict_base,
@@ -706,8 +705,22 @@ def call_locus(
 
     # LIMITATION: Currently can only use SNVs for haplotyping with haploid/diploid
     if should_incorporate_snvs:
+        # Loop through a second time if we are using SNVs. We do a second loop rather than just using the first loop
+        # in order to have collected the edges of the reference sequence we can cache for faster SNV calculation.
+
+        ref_cache = ref.fetch(contig, left_most_coord, right_most_coord + 1).upper()
+
+        for rn, read in read_dict_items:
+            snvs = get_read_snvs(
+                read["_qs"], read_pairs[rn], ref_cache, left_most_coord, left_coord_adj,
+                right_coord_adj)
+            locus_snvs.update(snvs.keys())
+            read_dict[rn]["snv"] = snvs
+
+        # End of second read loop --------------------------------------------------------------------------------------
+
         useful_snvs: list[tuple[int, int]] = (
-            calculate_useful_snvs(n_reads_in_dict, overlapping_segments, read_dict, read_pairs, locus_snvs)
+            calculate_useful_snvs(n_reads_in_dict, read_dict, read_dict_items, read_pairs, locus_snvs)
             if n_reads_in_dict >= min_snv_read_coverage else []
         )
         n_useful_snvs: int = len(useful_snvs)
@@ -787,6 +800,12 @@ def call_locus(
             del rd["snv"]
         if "snv_bases" in rd:
             del rd["snv_bases"]
+        if "_ref_start" in rd:
+            del rd["_ref_start"]
+        if "_ref_end" in rd:
+            del rd["_ref_end"]
+        if "_qs" in rd:
+            del rd["_qs"]
 
     # Extract data from call_data --------------------------------------------------------------------------------------
 

{strkit-0.8.0a5 → strkit-0.8.0a7}/strkit/call/caller/call_sample.py

@@ -138,7 +138,7 @@ def progress_worker(
         try:
             lg.info(
                 f"{sample_id}: processed {num_loci - max(locus_queue.qsize(), num_workers) + num_workers} loci in "
-                f"{round((datetime.now() - start_time).total_seconds())} seconds")
+                f"{(datetime.now() - start_time).total_seconds():.1f} seconds")
         except NotImplementedError:
             pass
 
@@ -297,7 +297,7 @@ def call_sample(
                 str(res["end"]),
                 res["motif"],
                 _cn_to_str(res["ref_cn"]),
-                ",".join(map(_cn_to_str, sorted(r["cn"] for r in res["reads"].values()))),
+                ",".join(map(_cn_to_str, sorted(r["cn"] for r in res["reads"].values()))) if res["reads"] else ".",
                 "|".join(map(_cn_to_str, res["call"])) if has_call else ".",
                 ("|".join("-".join(map(_cn_to_str, gc)) for gc in res["call_95_cis"]) if has_call else "."),
                 *((res["assign_method"] if has_call else ".",) if incorporate_snvs else ()),

{strkit-0.8.0a5 → strkit-0.8.0a7}/strkit/call/caller/snvs.py

@@ -23,8 +23,8 @@ SNV_OUT_OF_RANGE_CHAR = "-"
 def _get_read_snvs_meticulous(
     query_sequence: str,
     pairs: list[tuple[int, int], ...],
-    contig: str,
-    ref: pysam.FastaFile,
+    ref_seq: str,
+    ref_coord_start: int,
     tr_start_pos: int,
     tr_end_pos: int,
     contiguous_threshold: int = 5,
@@ -38,11 +38,6 @@ def _get_read_snvs_meticulous(
 
     snvs: dict[int, str] = {}
 
-    fm_qp, fm_rp = pairs[0]
-    lm_qp, lm_rp = pairs[-1]
-
-    ref_sequence: str = ref.fetch(contig, fm_rp, lm_rp + 1).upper()
-
     lhs_contiguous: int = 0
     rhs_contiguous: int = 0
     last_rp: int = -1
@@ -54,7 +49,7 @@ def _get_read_snvs_meticulous(
             continue
 
         read_base = query_sequence[read_pos]
-        ref_base = ref_sequence[ref_pos - fm_rp]
+        ref_base = ref_seq[ref_pos - ref_coord_start]
 
         if read_base == ref_base and (ref_pos - last_rp == 1 or last_rp == -1):
             if snv_group:
@@ -89,8 +84,8 @@ def _get_read_snvs_meticulous(
 def get_read_snvs(
     query_sequence: str,
     pairs: list[tuple[int, int], ...],
-    contig: str,
-    ref: pysam.FastaFile,
+    ref_seq: str,
+    ref_coord_start: int,
     tr_start_pos: int,
     tr_end_pos: int,
     contiguous_threshold: int = 5,
@@ -105,24 +100,18 @@ def get_read_snvs(
 
     snvs: dict[int, str] = {}
 
-    fm_qp, fm_rp = pairs[0]
-    lm_qp, lm_rp = pairs[-1]
-
-    # query_sequence = query_sequence.upper()
-    ref_sequence: str = ref.fetch(contig, fm_rp, lm_rp + 1).upper()
-
     for read_pos, ref_pos in pairs:
         if tr_start_pos <= ref_pos < tr_end_pos:  # base is in the tandem repeat itself; skip it
             continue
-        if (read_base := query_sequence[read_pos]) != ref_sequence[ref_pos - fm_rp]:
+        if (read_base := query_sequence[read_pos]) != ref_seq[ref_pos - ref_coord_start]:
             snvs[ref_pos] = read_base
 
     if len(snvs) >= too_many_snvs_threshold:  # TOO MANY, some kind of mismapping going on
         return _get_read_snvs_meticulous(
             query_sequence,
             pairs,
-            contig,
-            ref,
+            ref_seq,
+            ref_coord_start,
             tr_start_pos,
             tr_end_pos,
             contiguous_threshold,
@@ -134,26 +123,22 @@ def get_read_snvs(
 
 def calculate_useful_snvs(
     n_reads: int,
-    overlapping_segments: list[pysam.AlignedSegment],
     read_dict: dict[str, ReadDict],
+    read_dict_items: tuple[tuple[str, ReadDict], ...],
     read_match_pairs: dict[str, list[tuple[int, int]]],
     locus_snvs: set[int],
 ) -> list[tuple[int, int]]:
     sorted_snvs: list[int] = sorted(locus_snvs)
     snv_counters: dict[int, Counter] = {sp: Counter() for sp in sorted_snvs}
 
-    for segment in overlapping_segments:
-        rn = segment.query_name
-        if rn not in read_dict:
-            continue
-
+    for rn, read in read_dict_items:
         snvs: dict[int, str] = read_dict[rn]["snv"]
 
         # Know this to not be None since we were passed only segments with non-None strings earlier
-        qs: str = segment.query_sequence
+        qs: str = read["_qs"]
 
-        segment_start: int = segment.reference_start
-        segment_end: int = segment.reference_end
+        segment_start: int = read["_ref_start"]
+        segment_end: int = read["_ref_end"]
 
         snv_list: list[str] = []
 

{strkit-0.8.0a5 → strkit-0.8.0a7}/strkit/call/caller/types.py

@@ -1,3 +1,4 @@
+import pysam
 from typing import Literal, TypedDict, Union
 
 
@@ -26,6 +27,13 @@ class ReadDict(_ReadDictBase, total=False):
 
     kmers: dict[str, int]  # Dictionary of {kmer: count}
 
+    # Below are only added if SNVs are being incorporated:
+
     snv: dict[int, str]  # Intermediate result: dictionary of a bunch of SNVs for this read {position: base}
     snv_bases: tuple[str, ...]  # Intermediate result: tuple of bases for the set of SNVs across all reads
     snvu: tuple[str, ...]  # After including only useful SNVs, this contains a tuple of bases for just those
+
+    _ref_start: int  # Read start in ref coordinates
+    _ref_end: int  # Read end in ref coordinates
+
+    _qs: str  # Query (read) sequence... only added if SNVs are being incorporated

{strkit-0.8.0a5 → strkit-0.8.0a7/strkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strkit
-Version: 0.8.0a5
+Version: 0.8.0a7
 Summary: A toolkit for analyzing variation in short(ish) tandem repeats.
 Home-page: https://github.com/davidlougheed/strkit
 Author: David Lougheed

strkit-0.8.0a5/strkit/VERSION

@@ -1 +0,0 @@
-0.8.0a5