strkit 0.8.0a6__tar.gz → 0.8.0a8__tar.gz

{strkit-0.8.0a6/strkit.egg-info → strkit-0.8.0a8}/PKG-INFO

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

strkit-0.8.0a8/strkit/VERSION

@@ -0,0 +1 @@
+0.8.0a8

{strkit-0.8.0a6 → strkit-0.8.0a8}/strkit/call/caller/call_locus.py

@@ -218,6 +218,7 @@ def call_alleles_with_incorporated_snvs(
     fractional: bool,
     read_dict: dict[str, ReadDict],
     read_dict_items: tuple[tuple[str, ReadDict], ...],  # We could derive this again, but we already have before...
+    read_dict_extra: dict[str, dict],
     n_reads_in_dict: int,  # We could derive this again, but we already have before...
     useful_snvs: list[tuple[int, int]],
     rng: np.random.Generator,
@@ -235,7 +236,7 @@ def call_alleles_with_incorporated_snvs(
     print_snvs = False
 
     for rn, read in read_dict_items:
-        read_useful_snv_bases = tuple(read["snv_bases"][bi] for bi, _pos in useful_snvs)
+        read_useful_snv_bases = tuple(read_dict_extra[rn]["snv_bases"][bi] for bi, _pos in useful_snvs)
         non_blank_read_useful_snv_bases = [bb for bb in read_useful_snv_bases if bb != SNV_OUT_OF_RANGE_CHAR]
 
         if (nbr := len(non_blank_read_useful_snv_bases)) >= 2:  # TODO: parametrize
@@ -485,6 +486,7 @@ def call_locus(
     # Build the read dictionary with segment information, copy number, weight, & more. ---------------------------------
 
     read_dict: dict[str, ReadDict] = {}
+    read_dict_extra: dict[str, dict] = {}
 
     # Aggregations for additional read-level data
     read_kmers = Counter()
@@ -645,8 +647,6 @@ 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,
@@ -654,13 +654,17 @@ def call_locus(
             **({"chimeric_in_region": crs_cir} if crs_cir else {}),
             **({"kmers": dict(read_kmers)} if count_kmers != "none" else {}),
         }
+        read_dict_extra[rn] = {
+            "_ref_start": segment_start,
+            "_ref_end": segment_end,
+        }
 
         # Reads can show up more than once - TODO - cache this information across loci
 
         if should_incorporate_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
+            read_dict_extra[rn]["_qs"] = qs
 
     # End of first read loop -------------------------------------------------------------------------------------------
 
@@ -712,15 +716,15 @@ def call_locus(
 
         for rn, read in read_dict_items:
             snvs = get_read_snvs(
-                read["_qs"], read_pairs[rn], ref_cache, left_most_coord, right_most_coord, left_coord_adj,
+                read_dict_extra[rn]["_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
+            read_dict_extra[rn]["snv"] = snvs
 
         # End of second read loop --------------------------------------------------------------------------------------
 
         useful_snvs: list[tuple[int, int]] = (
-            calculate_useful_snvs(n_reads_in_dict, read_dict, read_dict_items, read_pairs, locus_snvs)
+            calculate_useful_snvs(n_reads_in_dict, read_dict_items, read_dict_extra, read_pairs, locus_snvs)
             if n_reads_in_dict >= min_snv_read_coverage else []
         )
         n_useful_snvs: int = len(useful_snvs)
@@ -736,6 +740,7 @@ def call_locus(
                 fractional=fractional,
                 read_dict=read_dict,
                 read_dict_items=read_dict_items,
+                read_dict_extra=read_dict_extra,
                 n_reads_in_dict=n_reads_in_dict,
                 useful_snvs=useful_snvs,
                 rng=rng,
@@ -793,20 +798,6 @@ def call_locus(
             debug_str=f"{contig}:{left_coord}-{right_coord}",
         ) or {}  # Still false-y
 
-    # Clean up read dict  TODO: nicer way to do this -------------------------------------------------------------------
-
-    for rn, rd in read_dict_items:
-        if "snv" in rd:
-            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 --------------------------------------------------------------------------------------
 
     call = call_data.get("call")

{strkit-0.8.0a6 → strkit-0.8.0a8}/strkit/call/caller/snvs.py

@@ -1,5 +1,4 @@
 import numpy as np
-import pysam
 from collections import Counter
 
 from numpy.typing import NDArray
@@ -25,7 +24,6 @@ def _get_read_snvs_meticulous(
     pairs: list[tuple[int, int], ...],
     ref_seq: str,
     ref_coord_start: int,
-    ref_coord_end: int,
     tr_start_pos: int,
     tr_end_pos: int,
     contiguous_threshold: int = 5,
@@ -39,11 +37,6 @@ def _get_read_snvs_meticulous(
 
     snvs: dict[int, str] = {}
 
-    fm_qp, fm_rp = pairs[0]
-    lm_qp, lm_rp = pairs[-1]
-
-    read_ref_sequence: str = ref_seq[fm_rp-ref_coord_start:lm_rp-ref_coord_end+1]
-
     lhs_contiguous: int = 0
     rhs_contiguous: int = 0
     last_rp: int = -1
@@ -55,7 +48,7 @@ def _get_read_snvs_meticulous(
             continue
 
         read_base = query_sequence[read_pos]
-        ref_base = read_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:
@@ -92,7 +85,6 @@ def get_read_snvs(
     pairs: list[tuple[int, int], ...],
     ref_seq: str,
     ref_coord_start: int,
-    ref_coord_end: int,
     tr_start_pos: int,
     tr_end_pos: int,
     contiguous_threshold: int = 5,
@@ -107,15 +99,10 @@ def get_read_snvs(
 
     snvs: dict[int, str] = {}
 
-    fm_qp, fm_rp = pairs[0]
-    lm_qp, lm_rp = pairs[-1]
-
-    read_ref_sequence: str = ref_seq[fm_rp-ref_coord_start:lm_rp-ref_coord_end]
-
     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]) != read_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
@@ -124,7 +111,6 @@ def get_read_snvs(
             pairs,
             ref_seq,
             ref_coord_start,
-            ref_coord_end,
             tr_start_pos,
             tr_end_pos,
             contiguous_threshold,
@@ -136,8 +122,8 @@ def get_read_snvs(
 
 def calculate_useful_snvs(
     n_reads: int,
-    read_dict: dict[str, ReadDict],
     read_dict_items: tuple[tuple[str, ReadDict], ...],
+    read_dict_extra: dict[str, dict],
     read_match_pairs: dict[str, list[tuple[int, int]]],
     locus_snvs: set[int],
 ) -> list[tuple[int, int]]:
@@ -145,13 +131,15 @@ def calculate_useful_snvs(
     snv_counters: dict[int, Counter] = {sp: Counter() for sp in sorted_snvs}
 
     for rn, read in read_dict_items:
-        snvs: dict[int, str] = read_dict[rn]["snv"]
+        extra_data = read_dict_extra[rn]
+
+        snvs: dict[int, str] = extra_data["snv"]
 
         # Know this to not be None since we were passed only segments with non-None strings earlier
-        qs: str = read["_qs"]
+        qs: str = extra_data["_qs"]
 
-        segment_start: int = read["_ref_start"]
-        segment_end: int = read["_ref_end"]
+        segment_start: int = extra_data["_ref_start"]
+        segment_end: int = extra_data["_ref_end"]
 
         snv_list: list[str] = []
 
@@ -191,7 +179,7 @@ def calculate_useful_snvs(
             snv_list.append(base)
             snv_counters[snv_pos][base] += 1
 
-        read_dict[rn]["snv_bases"] = tuple(snv_list)
+        extra_data["snv_bases"] = tuple(snv_list)
 
     # Enough reads to try for SNV based separation
     useful_snvs: list[int] = []

{strkit-0.8.0a6 → strkit-0.8.0a8/strkit.egg-info}/PKG-INFO

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

strkit-0.8.0a6/strkit/VERSION

@@ -1 +0,0 @@
-0.8.0a6