strkit 0.15.0a22__tar.gz → 0.16.0__tar.gz

{strkit-0.15.0a22/strkit.egg-info → strkit-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strkit
-Version: 0.15.0a22
+Version: 0.16.0
 Summary: A toolkit for analyzing variation in short(ish) tandem repeats.
 Home-page: https://github.com/davidlougheed/strkit
 Author: David Lougheed
@@ -20,7 +20,7 @@ Requires-Dist: parasail<1.4,>=1.2.4
 Requires-Dist: scikit-learn<1.5,>=1.2.1
 Requires-Dist: scipy<1.14,>=1.10
 Requires-Dist: statsmodels<0.15,>=0.14.0
-Requires-Dist: strkit_rust_ext==0.12.2
+Requires-Dist: strkit_rust_ext==0.13.0
 
 # STRkit - short tandem repeat genotyping with long reads
 
@@ -88,10 +88,10 @@ You may need to install the [Rust toolchain](https://www.rust-lang.org/tools/ins
 to compile the `strkit_rust_ext` wheels, although prebuilt wheels for this module are available
 for some platforms.
 
-On Digital Research Alliance of Canada/Compute Canada clusters, this involves loading a module:
+On Digital Research Alliance of Canada/Compute Canada clusters, this involves loading a few modules:
 
 ```bash
-module load rust/1.76.0
+module load rust/1.76.0 clang/17.0.6 python/3.11 scipy-stack/2023b parasail/2.6.2
 python -m pip install strkit
 ```
 
@@ -138,8 +138,8 @@ long read data should still work.
   * Whole-genome and targeted genotyping modes to adjust this re-weighting.
 * Incorporation of single-nucleotide variation (SNVs) for better and faster calling plus 
   additional downstream analysis possibilities.
-  * Recommended for **HiFi data only**. In my testing, this worsens runtime and call quality for 
-    ONT-UL data, but speeds up the tool and improves call quality for HiFi data. 
+  * Recommended for **HiFi data and ONT duplex data only**. In my testing, this worsens runtime and call quality for 
+    ONT ultra-long-read data, but speeds up the tool and improves call quality for HiFi/ONT duplex data. 
 * Parallelized for faster computing on clusters and for ad-hoc fast analysis of single samples.
 * 95% confidence intervals on calls via a user-configurable optional parametric bootstrapping process.
 
@@ -149,7 +149,7 @@ long read data should still work.
 ```bash
 strkit call \
   path/to/read/file.bam \  # [REQUIRED] One indexed read file (BAM/CRAM)
-  --hq \  # If using PacBio HiFi reads, enable this to get better genotyping & more robust expansion detection
+  --hq \  # If using PacBio HiFi or ONT duplex reads, enable this to get better genotyping & more robust expansion detection
   --realign \  # If using PacBio HiFi reads, enable this to enable local realignment / read recovery. Good for detecting expansions, but slows down calling.
   --ref path/to/reference.fa.gz \  # [REQUIRED] Indexed FASTA-formatted reference genome
   --loci path/to/loci.bed \  # [REQUIRED] TRF-formatted (or 4-col, with motif as last column) sorted list of loci to genotype
@@ -187,7 +187,6 @@ If you want to output a full call report, you can use the `--json output-file.js
 specify a path to output a more detailed JSON document to. This document contains 99% CIs, peak
 labels, and some other information that isn't included in the normal TSV file. If you want this
 file to be indented and human-readable, use the `--indent-json` flag in addition to `--json ...`.
-Note that **memory usage will be higher** when JSON output is enabled.
 
 If you want to output a VCF file (STRs and SNVs if called; currently not phased), use the
 `--vcf ...` argument. If you pass `--vcf stdout`, the VCF will be written to `stdout` instead of a 

{strkit-0.15.0a22 → strkit-0.16.0}/README.md

@@ -64,10 +64,10 @@ You may need to install the [Rust toolchain](https://www.rust-lang.org/tools/ins
 to compile the `strkit_rust_ext` wheels, although prebuilt wheels for this module are available
 for some platforms.
 
-On Digital Research Alliance of Canada/Compute Canada clusters, this involves loading a module:
+On Digital Research Alliance of Canada/Compute Canada clusters, this involves loading a few modules:
 
 ```bash
-module load rust/1.76.0
+module load rust/1.76.0 clang/17.0.6 python/3.11 scipy-stack/2023b parasail/2.6.2
 python -m pip install strkit
 ```
 
@@ -114,8 +114,8 @@ long read data should still work.
   * Whole-genome and targeted genotyping modes to adjust this re-weighting.
 * Incorporation of single-nucleotide variation (SNVs) for better and faster calling plus 
   additional downstream analysis possibilities.
-  * Recommended for **HiFi data only**. In my testing, this worsens runtime and call quality for 
-    ONT-UL data, but speeds up the tool and improves call quality for HiFi data. 
+  * Recommended for **HiFi data and ONT duplex data only**. In my testing, this worsens runtime and call quality for 
+    ONT ultra-long-read data, but speeds up the tool and improves call quality for HiFi/ONT duplex data. 
 * Parallelized for faster computing on clusters and for ad-hoc fast analysis of single samples.
 * 95% confidence intervals on calls via a user-configurable optional parametric bootstrapping process.
 
@@ -125,7 +125,7 @@ long read data should still work.
 ```bash
 strkit call \
   path/to/read/file.bam \  # [REQUIRED] One indexed read file (BAM/CRAM)
-  --hq \  # If using PacBio HiFi reads, enable this to get better genotyping & more robust expansion detection
+  --hq \  # If using PacBio HiFi or ONT duplex reads, enable this to get better genotyping & more robust expansion detection
   --realign \  # If using PacBio HiFi reads, enable this to enable local realignment / read recovery. Good for detecting expansions, but slows down calling.
   --ref path/to/reference.fa.gz \  # [REQUIRED] Indexed FASTA-formatted reference genome
   --loci path/to/loci.bed \  # [REQUIRED] TRF-formatted (or 4-col, with motif as last column) sorted list of loci to genotype
@@ -163,7 +163,6 @@ If you want to output a full call report, you can use the `--json output-file.js
 specify a path to output a more detailed JSON document to. This document contains 99% CIs, peak
 labels, and some other information that isn't included in the normal TSV file. If you want this
 file to be indented and human-readable, use the `--indent-json` flag in addition to `--json ...`.
-Note that **memory usage will be higher** when JSON output is enabled.
 
 If you want to output a VCF file (STRs and SNVs if called; currently not phased), use the
 `--vcf ...` argument. If you pass `--vcf stdout`, the VCF will be written to `stdout` instead of a 

{strkit-0.15.0a22 → strkit-0.16.0}/setup.py

@@ -22,7 +22,7 @@ setup(
         "scikit-learn>=1.2.1,<1.5",
         "scipy>=1.10,<1.14",
         "statsmodels>=0.14.0,<0.15",
-        "strkit_rust_ext==0.12.2",
+        "strkit_rust_ext==0.13.0",
     ],
 
     description="A toolkit for analyzing variation in short(ish) tandem repeats.",

strkit-0.16.0/strkit/VERSION

@@ -0,0 +1 @@
+0.16.0

{strkit-0.15.0a22 → strkit-0.16.0}/strkit/call/allele.py

@@ -58,7 +58,7 @@ def _array_as_int(n: Union[NDArray[np.int_], NDArray[np.float_]]) -> NDArray[np.
     return np.rint(n).astype(np.int32)
 
 
-def _calculate_cis(samples, ci: str = Literal["95", "99"]) -> Union[NDArray[np.int32], NDArray[np.float_]]:
+def _calculate_cis(samples, ci: str = Literal["95", "99"]) -> NDArray[np.int32]:
     percentiles = np.percentile(
         samples, CI_PERCENTILE_RANGES[ci], axis=1, method="interpolated_inverted_cdf"
     ).transpose()
@@ -145,7 +145,7 @@ def fit_gmm(
     return g
 
 
-class CallDict(TypedDict):
+class BaseCallDict(TypedDict):
     call: Union[NDArray[np.int32], NDArray[np.float_]]
     call_95_cis: Union[NDArray[np.int32], NDArray[np.float_]]  # 2D arrays
     call_99_cis: Union[NDArray[np.int32], NDArray[np.float_]]  # 2D arrays
@@ -155,6 +155,10 @@ class CallDict(TypedDict):
     modal_n_peaks: int
 
 
+class CallDict(BaseCallDict, total=False):
+    ps: int
+
+
 def make_read_weights(read_weights: Optional[Iterable[float]], num_reads: int) -> NDArray[np.float_]:
     return np.array(
         read_weights if read_weights is not None else np.array(([1/num_reads] * num_reads) if num_reads else []))
@@ -262,7 +266,7 @@ def call_alleles(
     gmm_cache = {}
 
     def _get_fitted_gmm(s: Union[NDArray[np.int_], NDArray[np.float_]]) -> Optional[object]:
-        if (s_t := tuple(s)) not in gmm_cache:
+        if (s_t := s.tobytes()) not in gmm_cache:
             # Fit Gaussian mixture model to the resampled data
             gmm_cache[s_t] = fit_gmm(rng, s, n_alleles, allele_filter, params.hq, gm_filter_factor)
 
@@ -335,17 +339,19 @@ def call_alleles(
     median_idx = allele_samples.shape[1] // 2  #
     medians_of_means = allele_samples[:, median_idx]
     medians_of_means_final = np.rint(medians_of_means).astype(np.int32)
-    peak_weights = allele_weight_samples[:, median_idx]
+    peak_weights = allele_weight_samples[:, median_idx].flatten()
     peak_stdevs = allele_stdev_samples[:, median_idx]
     modal_n_peaks: int = statistics.mode(sample_peaks).item()
 
+    peak_weights /= peak_weights.sum()  # re-normalize weights
+
     return {
         "call": medians_of_means_final.flatten(),
         "call_95_cis": allele_cis_95,
         "call_99_cis": allele_cis_99,
 
         "peaks": medians_of_means.flatten(),  # Don't round, so we can recover original Gaussian model
-        "peak_weights": peak_weights.flatten(),
+        "peak_weights": peak_weights,
         "peak_stdevs": peak_stdevs.flatten(),
         # TODO: should be ok to use this, because resample gets put at end, vertically (3rd allele in a 3-ploid case)
         #  so taking the first 2 alleles still works in terms of stdev/mean estimates? I think?

{strkit-0.15.0a22 → strkit-0.16.0}/strkit/call/call_locus.py

@@ -2,12 +2,9 @@ from __future__ import annotations
 
 import functools
 import logging
-import multiprocessing as mp
 import multiprocessing.managers as mmg
 import numpy as np
 import operator
-import queue
-import time
 import threading
 
 from collections import Counter
@@ -15,22 +12,23 @@ from collections.abc import Sequence
 from datetime import datetime
 from pysam import FastaFile
 from sklearn.cluster import AgglomerativeClustering
+from sklearn.mixture import GaussianMixture
 
 from numpy.typing import NDArray
-from typing import Iterable, Literal, Optional, Union
+from typing import Iterable, Optional, Union
 
 from strkit_rust_ext import (
     get_pairs_and_tr_read_coords, STRkitBAMReader, STRkitAlignedSegment, STRkitVCFReader, CandidateSNVs
 )
 
 from strkit.call.allele import CallDict, call_alleles
-from strkit.utils import cat_strs, apply_or_none
+from strkit.utils import apply_or_none
 
 from .align_matrix import match_score
 from .cigar import decode_cigar_np
-from .consensus import ConsensusMethod, consensus_seq
+from .consensus import consensus_seq
 from .params import CallParams
-from .realign import realign_read
+from .realign import perform_realign
 from .repeats import get_repeat_count, get_ref_repeat_count
 from .snvs import (
     SNV_GAP_CHAR,
@@ -38,8 +36,10 @@ from .snvs import (
     call_and_filter_useful_snvs,
     process_read_snvs_for_locus_and_calculate_useful_snvs,
 )
-from .types import ReadDict, ReadDictExtra, CalledSNV
-from .utils import idx_0_getter, find_pair_by_ref_pos, normalize_contig, get_new_seed
+from .types import (
+    VCFContigFormat, AssignMethod, AssignMethodWithHP, ConsensusMethod, ReadDict, ReadDictExtra, CalledSNV, LocusResult
+)
+from .utils import idx_0_getter, find_pair_by_ref_pos, normalize_contig, get_new_seed, calculate_seq_with_wildcards
 
 
 __all__ = [
@@ -56,7 +56,6 @@ default_ref_max_iters: int = 250
 ref_max_iters_to_be_slow: int = 100
 
 max_rc_iters = 50
-min_read_score = 0.9  # TODO: parametrize
 # TODO: Parametrize - if very low alignment or very slow, then "bad read"
 extremely_low_read_adj_score: float = 0.1  # fraction
 bad_read_alignment_time: int = 15  # seconds
@@ -65,6 +64,8 @@ max_bad_reads: int = 3
 
 base_wildcard_threshold = 3
 
+min_hp_read_coverage: int = 8  # TODO: parametrize
+
 roughly_equiv_stdev_dist = 1
 
 force_realign = False
@@ -73,7 +74,8 @@ many_realigns_threshold = 2
 significant_clip_threshold = 100
 significant_clip_snv_take_in = 250
 
-max_poa_length = 5000  # maximum number of bases before we can't use POA for consensus anymore due to performance
+# maximum median number of bases before we can't use POA for consensus anymore due to performance:
+max_mdn_poa_length = 5000
 
 
 # property getters & other partials
@@ -83,17 +85,6 @@ not_snv_out_of_range_char = functools.partial(operator.ne, SNV_OUT_OF_RANGE_CHAR
 eq_0 = functools.partial(operator.eq, 0)
 
 
-@functools.cache
-def _mask_low_q_base(base_and_qual: tuple[str, int]) -> str:
-    return base_and_qual[0] if base_and_qual[1] > base_wildcard_threshold else "X"
-
-
-def calculate_seq_with_wildcards(qs: str, quals: Optional[NDArray[np.uint8]]) -> str:
-    if quals is None:
-        return qs  # No quality information, so don't do anything
-    return cat_strs(map(_mask_low_q_base, zip(qs, quals)))
-
-
 def get_read_coords_from_matched_pairs(
     left_flank_coord: int,
     left_coord: int,
@@ -131,8 +122,8 @@ def get_read_coords_from_matched_pairs(
     # ------------------------------------------------------------------------------------------------------------------
 
     for i in range(lhs + 1, len(q_coords)):
-        query_coord = q_coords[i]
-        ref_coord = r_coords[i]
+        query_coord = q_coords[i].item()
+        ref_coord = r_coords[i].item()
 
         # Skip gaps on either side to find mapped flank indices
         if ref_coord < left_coord:
@@ -514,8 +505,8 @@ def call_alleles_with_incorporated_snvs(
     rng: np.random.Generator,
     logger_: logging.Logger,
     locus_log_str: str,
-) -> tuple[Literal["dist", "snv", "snv+dist", "single"], Optional[tuple[dict, list[dict]]]]:
-    assign_method: Literal["dist", "snv", "snv+dist", "single"] = "dist"
+) -> tuple[AssignMethod, Optional[tuple[dict, list[CalledSNV]]]]:
+    assign_method: AssignMethod = "dist"
 
     # TODO: parametrize min 'enough to do pure SNV haplotyping' thresholds
 
@@ -524,8 +515,6 @@ def call_alleles_with_incorporated_snvs(
     read_dict_items_with_at_least_one_snv: list[tuple[str, ReadDict]] = []
     read_dict_items_with_no_snvs: list[tuple[str, ReadDict]] = []
 
-    print_snvs = False
-
     # TODO: Check that we don't have disjoint groups - how would we actually ascertain this?
     #  - each read as a set; merge sets when there is overlap, make sure we have 1 set at the end
 
@@ -556,10 +545,6 @@ def call_alleles_with_incorporated_snvs(
 
         read["snvu"] = read_useful_snv_bases  # Store read-level 'useful' SNVs
 
-        if print_snvs:
-            print(
-                rn, f"\t{read['cn']:.0f}", "\t", read_useful_snv_bases, n_non_blank_hq_read_useful_snv_bases)
-
     n_reads_with_many_snvs: int = len(read_dict_items_with_many_snvs)
     n_reads_with_at_least_one_snv: int = len(read_dict_items_with_at_least_one_snv)
     n_reads_with_no_snvs: int = len(read_dict_items_with_no_snvs)
@@ -738,7 +723,7 @@ def call_alleles_with_incorporated_snvs(
     peak_weights_pre_adj = np.concatenate(tuple(cc["peak_weights"] for cc in cdd), axis=0)
 
     # All call_datas are truth-y; all arrays should be ordered by peak_order
-    call_data = {
+    call_data: CallDict = {
         "call": np.concatenate(tuple(cc["call"] for cc in cdd_ordered), axis=0),
         "call_95_cis": np.concatenate(tuple(cc["call_95_cis"] for cc in cdd_ordered), axis=0),
         "call_99_cis": np.concatenate(tuple(cc["call_99_cis"] for cc in cdd_ordered), axis=0),
@@ -797,20 +782,20 @@ def call_locus(
     # ---
     snv_vcf_file: Optional[STRkitVCFReader] = None,
     snv_vcf_contigs: tuple[str, ...] = (),
-    snv_vcf_file_format: Literal["chr", "num", "acc", ""] = "",
+    snv_vcf_file_format: VCFContigFormat = "",
     # ---
     read_file_has_chr: bool = True,
     ref_file_has_chr: bool = True,
-) -> Optional[dict]:
+) -> Optional[LocusResult]:
     call_timer = datetime.now()
 
     # params de-structuring ------------
     consensus = params.consensus
     count_kmers = params.count_kmers
     flank_size = params.flank_size
-    log_level = params.log_level
     realign = params.realign
     respect_ref = params.respect_ref
+    min_read_align_score = params.min_read_align_score
     snv_min_base_qual = params.snv_min_base_qual
     # ----------------------------------
 
@@ -830,7 +815,7 @@ def call_locus(
     ref_seq: str = ""
     raised: bool = False
 
-    call_dict_base = {
+    locus_result: LocusResult = {
         "locus_index": t_idx,
         "contig": contig,
         "start": left_coord,
@@ -872,15 +857,15 @@ def call_locus(
         raised = True
 
     if raised:
-        return None  # don't even return call_dict_base, this locus has an invalid position
+        return None  # don't even return locus_result, this locus has an invalid position
 
     if len(ref_left_flank_seq) < params.flank_size or len(ref_right_flank_seq) < params.flank_size:
         logger_.warning(f"{locus_log_str} - skipping locus, reference flank size too small")
-        return call_dict_base
+        return locus_result
 
     if ref_left_flank_seq.endswith("N" * motif_size) or ref_right_flank_seq.startswith("N" * motif_size):
         logger_.warning(f"{locus_log_str} - skipping locus, reference has flanking N[...] sequence")
-        return call_dict_base
+        return locus_result
 
     # Get reference repeat count by our method, so we can calculate offsets from reference
     #  - Replace flanking/ref TR sequences with adjusted sequences
@@ -917,12 +902,12 @@ def call_locus(
         local_search_range=ref_local_search_range,
         step_size=ref_step_size,
     )
-    call_dict_base["ref_cn"] = ref_cn  # tag call dictionary with ref_cn
+    locus_result["ref_cn"] = ref_cn  # tag call dictionary with ref_cn
 
     slow_ref_count = any(x > ref_max_iters_to_be_slow for x in r_n_is)
 
     logger_.debug(
-        f"{locus_log_str} - got ref. copy number: {ref_cn} ({l_offset=}; {r_offset=}; iters={r_n_is})")
+        f"{locus_log_str} - {ref_cn=} (l.o.={l_offset}; r.o.={r_offset}; #i={r_n_is})")
 
     if slow_ref_count:
         logger_.warning(f"{locus_log_str} - slow reference copy number counting ({motif=}; {ref_cn=}; iters={r_n_is})")
@@ -933,11 +918,9 @@ def call_locus(
     left_coord_adj = left_coord if respect_ref else left_coord - max(0, l_offset)
     right_coord_adj = right_coord if respect_ref else right_coord + max(0, r_offset)
 
-    if not respect_ref:  # tag call_dict_base with adjusted start/end
-        call_dict_base.update({
-            "start_adj": left_coord_adj,
-            "end_adj": right_coord_adj,
-        })
+    if not respect_ref:  # tag locus_result with adjusted start/end
+        locus_result["start_adj"] = left_coord_adj
+        locus_result["end_adj"] = right_coord_adj
 
     ref_time = (datetime.now() - ref_timer).total_seconds()
 
@@ -965,9 +948,8 @@ def call_locus(
 
     logger_.debug(f"{locus_log_str} - got {n_overlapping_reads} overlapping aligned segments")
 
-    if n_overlapping_reads > params.max_reads:
-        logger_.warning(f"{locus_log_str} - skipping locus; too many overlapping reads")
-        return call_dict_base
+    if n_overlapping_reads > params.max_reads:  # TODO: sample across full set instead?
+        logger_.warning(f"{locus_log_str} - locus has excess reads, using the first {params.max_reads}; misalignment?")
 
     sorted_read_lengths = np.sort(read_lengths)
 
@@ -1034,40 +1016,21 @@ def call_locus(
             # Run the realignment in a separate process, to give us a timeout mechanism.
             # This means we're spawning a second process for this job, just momentarily, beyond the pool size.
 
-            q: mp.Queue = mp.Queue()
-            proc = mp.Process(target=realign_read, daemon=False, kwargs=dict(
-                # fetch an extra base for the right flank coordinate check later (needs to be >= the exclusive coord)
-                ref_seq=ref_total_seq,  # TODO: with the plus 1, really?
-                query_seq=calculate_seq_with_wildcards(qs, fqqs),
-                left_flank_coord=left_flank_coord,
-                flank_size=flank_size,
-                rn=rn,
-                t_idx=t_idx,
-                always_realign=force_realign,
-                q=q,
-                log_level=log_level,
-            ))
-            proc.start()
-            pairs_new = None
-            try:
-                pairs_new = q.get(timeout=realign_timeout)
-                proc.join()
-            except queue.Empty:
-                logger_.warning(
-                    f"{locus_log_str} - experienced timeout while re-aligning read {rn}. Reverting to initial "
-                    f"alignment.")
-                proc.terminate()
-                time.sleep(0.1)  # wait a little for the process to terminate
-            finally:
-                wait_count: int = 0
-                while proc.is_alive():
-                    logger_.warning(f"{locus_log_str} - realign job has still not exited. Waiting 0.5 seconds...")
-                    time.sleep(0.5)
-                    wait_count += 1
-                    if wait_count > 5:
-                        logger_.fatal(f"{locus_log_str} - realign job never exited. Terminating...")
-                        exit(1)
-                proc.close()
+            pairs_new = perform_realign(
+                t_idx,
+                left_flank_coord,
+                ref_total_seq,
+                rn,
+                qs,
+                fqqs,
+                # ---
+                params,
+                realign_timeout,
+                force_realign,
+                # ---
+                logger_,
+                locus_log_str,
+            )
 
             if pairs_new is not None:
                 q_coords, r_coords = pairs_new
@@ -1166,8 +1129,8 @@ def call_locus(
         rc_time = (datetime.now() - rc_timer).total_seconds()
 
         logger_.debug(
-            f"{locus_log_str} - {rn} | start: {read_sc}, offset frac.: {read_offset_frac_from_starting_guess:.4f} | "
-            f"rc time: {rc_time}, copy number: {read_cn}, score: {read_cn_score}")
+            f"{locus_log_str} - {rn} | start={read_sc}, o.f.={read_offset_frac_from_starting_guess:.4f} | "
+            f"rct={rc_time}s, cn={read_cn}, s={read_cn_score}")
 
         if n_read_cn_iters >= max_rc_iters:
             logger_.debug(f"{locus_log_str} - locus repeat counting exceeded maximum # iterations ({n_read_cn_iters})")
@@ -1178,7 +1141,7 @@ def call_locus(
         if rc_time >= really_bad_read_alignment_time:
             logger_.debug(
                 f"{locus_log_str} - not calling locus due to a pathologically-poorly-aligning read ({rn}; "
-                f"repeat count alignment scored {read_adj_score:.2f} < {min_read_score}; get_repeat_count time: "
+                f"repeat count alignment scored {read_adj_score:.2f} < {min_read_align_score}; get_repeat_count time: "
                 f"{rc_time:.3f}s; # get_repeat_count iters: {n_read_cn_iters}; {motif=}; {ref_cn=})")
             logger_.debug(f"{locus_log_str} - ref left flank:  {ref_left_flank_seq}")
             logger_.debug(f"{locus_log_str} - read left flank: {flank_left_seq}")
@@ -1187,16 +1150,16 @@ def call_locus(
             logger_.debug(f"{locus_log_str} - ref right flank:  {ref_right_flank_seq}")
             logger_.debug(f"{locus_log_str} - read right flank: {flank_right_seq}")
             return {
-                **call_dict_base,
+                **locus_result,
                 "peaks": None,
                 "read_peaks_called": False,
                 "time": (datetime.now() - call_timer).total_seconds(),
             }
 
-        if read_adj_score < min_read_score:
+        if read_adj_score < min_read_align_score:
             logger_.debug(
                 f"{locus_log_str} - skipping read {rn} (repeat count alignment scored {read_adj_score:.2f} < "
-                f"{min_read_score}; get_repeat_count time: {rc_time:.3f}s; # get_repeat_count iters: "
+                f"{min_read_align_score}; get_repeat_count time: {rc_time:.3f}s; # get_repeat_count iters: "
                 f"{n_read_cn_iters})")
 
             if read_adj_score < extremely_low_read_adj_score or rc_time >= bad_read_alignment_time:
@@ -1206,7 +1169,7 @@ def call_locus(
                         f"{locus_log_str} - not calling locus due to >3 extremely poor-aligning reads (TR seq: "
                         f"{tr_read_seq_wc[:20]}...)")
                     return {
-                        **call_dict_base,
+                        **locus_result,
                         "peaks": None,
                         "read_peaks_called": False,
                         "time": (datetime.now() - call_timer).total_seconds(),
@@ -1263,7 +1226,7 @@ def call_locus(
 
                 phase_set_lock.release()
 
-                read_dict[rn]["hp"] = hp
+                read_dict[rn]["hp"] = hp  # not none inside this if-statement
                 read_dict[rn]["ps"] = ps_remapped
                 haplotags.add(hp)
                 haplotagged_reads_count += 1
@@ -1294,7 +1257,7 @@ def call_locus(
 
     n_reads_in_dict: int = len(read_dict)
 
-    call_dict_base.update({
+    locus_result.update({
         # TODO: alt anchors:
         **({"ref_start_anchor": ref_left_flank_seq[-1], "ref_seq": ref_seq} if consensus else {}),
         "reads": read_dict,
@@ -1304,7 +1267,7 @@ def call_locus(
     if n_reads_in_dict < params.min_reads:
         logger_.debug(f"{locus_log_str} - not enough reads to make a call ({n_reads_in_dict} < {params.min_reads})")
         return {
-            **call_dict_base,
+            **locus_result,
             "peaks": None,
             "read_peaks_called": False,
             "time": (datetime.now() - call_timer).total_seconds(),
@@ -1316,11 +1279,7 @@ def call_locus(
     # noinspection PyTypeChecker
     read_dict_items: tuple[tuple[str, ReadDict], ...] = tuple(read_dict.items())
 
-    assign_method: Literal["dist", "snv", "snv+dist", "single", "hp"] = "dist"
-    if n_alleles < 2:
-        assign_method = "single"
-
-    min_hp_read_coverage: int = 8  # TODO: parametrize
+    assign_method: AssignMethodWithHP = "single" if n_alleles == 1 else "dist"
 
     # Realigns are missing significant amounts of flanking information since the realignment only uses a portion of the
     # reference genome. If we have a rare realignment (e.g., a large expansion), we cannot use SNVs.
@@ -1413,7 +1372,7 @@ def call_locus(
                 assign_method = am
                 if call_res is not None:
                     call_data = call_res[0]  # Call data dictionary
-                    call_dict_base["snvs"] = call_res[1]  # Called useful SNVs
+                    locus_result["snvs"] = call_res[1]  # Called useful SNVs
 
     single_or_dist_assign: bool = assign_method in ("single", "dist")
 
@@ -1477,16 +1436,22 @@ def call_locus(
                 # Hack: add small value to stdevs if we are exactly sure to make the below code work okay
                 stdevs += 0.00001
 
-            sd_dist = np.abs((peaks - cn) / stdevs)
-            weighted_dist = np.abs(((peaks - cn) / stdevs) * weights)
+            # np.abs((peaks - cn) / stdevs) is copy number distance from each peak, in # standard deviations
+            peak: int
+            if call_modal_n == 2 and np.all(np.abs((peaks - cn) / stdevs) < roughly_equiv_stdev_dist):
+                # Hack: if both peaks are 1 stdev away, pretend we aren't sure and fill in whichever allele has less
+                peak = int(len(allele_reads[0]) > len(allele_reads[1]))
+            else:
+                # Create an already-fitted Gaussian mixture instance and use it to predict the peak
 
-            # Hack: if both peaks are 1 stdev away, pretend we aren't sure and fill in whichever allele has less
-            peak: int = (
-                # bool to int conversion: 1 if we add to allele_reads[1]
-                int(len(allele_reads[0]) > len(allele_reads[1]))
-                if call_modal_n == 2 and np.all(sd_dist < roughly_equiv_stdev_dist)
-                else np.argmin(weighted_dist).item()
-            )
+                g: GaussianMixture = GaussianMixture(n_components=call_modal_n, covariance_type="spherical")
+                g.means_ = peaks.reshape(-1, 1)
+                g.covariances_ = stdevs ** 2
+                g.weights_ = weights
+                # see https://github.com/scikit-learn/scikit-learn/blob/1.5.0/sklearn/mixture/_gaussian_mixture.py#L347
+                g.precisions_cholesky_ = 1.0 / stdevs
+
+                peak = g.predict([[cn]])[0].item()
 
             allele_reads[peak].append(r)
             rd["p"] = peak
@@ -1515,16 +1480,16 @@ def call_locus(
                     lambda a: consensus_seq(
                         map(lambda rr: read_dict_extra[rr]["_tr_seq"], a),
                         logger_,
-                        max_poa_length=max_poa_length,
+                        max_mdn_poa_length=max_mdn_poa_length,
                     ),
                     allele_reads,
                 )
             )
 
     peak_data = {
-        "means": call_peaks.tolist(),  # from np.ndarray
-        "weights": call_weights.tolist(),  # from np.ndarray
-        "stdevs": call_stdevs.tolist(),  # from np.ndarray
+        "means": call_peaks,
+        "weights": call_weights,
+        "stdevs": call_stdevs,
         "modal_n": call_modal_n,
         "n_reads": call_peak_n_reads,
         **({"kmers": list(map(dict, peak_kmers))} if count_kmers in ("peak", "both") else {}),
@@ -1552,16 +1517,13 @@ def call_locus(
         f"{locus_log_str} - got call: {call_val} (95% CIs: {call_95_cis_val}); peak assign method={assign_method}; "
         f"# reads={call_peak_n_reads}")
 
-    return {
-        **call_dict_base,
-        "assign_method": assign_method,
-        "call": call_val,
-        "call_95_cis": call_95_cis_val,
-        "call_99_cis": apply_or_none(_nested_ndarray_serialize, call_99_cis),
-        "peaks": peak_data,
-        "ps": call_ps,
-        # make typecheck happy above by checking all of these are not None (even though if call is false-y, all of them
-        # should be None and otherwise none of them should).
-        "read_peaks_called": read_peaks_called,
-        "time": call_time,
-    }
+    locus_result["assign_method"] = assign_method
+    locus_result["call"] = call_val
+    locus_result["call_95_cis"] = call_95_cis_val
+    locus_result["call_99_cis"] = apply_or_none(_nested_ndarray_serialize, call_99_cis)
+    locus_result["peaks"] = peak_data
+    locus_result["ps"] = call_ps
+    locus_result["read_peaks_called"] = read_peaks_called
+    locus_result["time"] = call_time
+
+    return locus_result