strkit 0.8.0a25__tar.gz → 0.8.1__tar.gz

{strkit-0.8.0a25/strkit.egg-info → strkit-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strkit
-Version: 0.8.0a25
+Version: 0.8.1
 Summary: A toolkit for analyzing variation in short(ish) tandem repeats.
 Home-page: https://github.com/davidlougheed/strkit
 Author: David Lougheed
@@ -80,6 +80,7 @@ strkit call \
   --realign \  # If using PacBio HiFi reads, enable this to enable local realignment / read recovery
   --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) list of loci to genotype
+  --incorporate-snvs path/to/dbsnp.vcf.gz \   # If you want SNV calls to help phase STRs & speed up STRkit, include this
   --min-reads 4 \  # Minimum number of supporting reads needed to make a call
   --min-allele-reads 2 \  # Minimum number of supporting reads needed to call a specific allele size 
   --flank-size 70 \  # Size of the flanking region to use on either side of a region to properly anchor reads
@@ -91,14 +92,20 @@ PacBio provides a
 [recommended workflow](https://github.com/PacificBiosciences/apps-scripts/tree/master/RepeatAnalysisTools)
 for CCS alignment in this scenario.
 
-If you're using HiFi reads as input, **use the `--hq` and `--realign` options** to get better genotype calculation
-and a greater proportion of reads incorporated into the computed genotypes, respectively. 
-These should not add much performance overhead.
+If you're using HiFi reads as input, **use the `--hq` and `--realign` options** to get better 
+genotype calculation and a greater proportion of reads incorporated into the computed genotypes, 
+respectively. These should not add much performance overhead.
 
 If more than one read file is specified, the reads will be pooled. This can come in handy if you
 have e.g. multiple flow cells of the same sample split into different BAM files, or the reads are
 split by chromosome.
 
+If you want to incorporate SNV calling into the process, which speeds up runtime and gives
+marginally better calling results, you must provide an indexed, `bgzip`-compressed SNV catalog 
+VCF which matches your reference genome. You can find dbSNP VCFs at
+[`https://ftp.ncbi.nih.gov/snp/organisms/human_9606/VCF/`](https://ftp.ncbi.nih.gov/snp/organisms/human_9606/VCF/).
+The file for GRCh38 is called `00-common_all.vcf.gz` as of time of writing.
+
 If you want to output a full call report, you can use the `--json output-file.json` argument to
 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
@@ -117,7 +124,7 @@ samtools faidx my-reference.fa.gz  # Generates a .fai index file
 
 ##### Note on OpenMP Threading
 
-Slow performance can result from running `strkit call` or `strkit re-call` on a system with OpenMP, 
+Slow performance can result from running `strkit call` on a system with OpenMP, 
 due to a misguided  attempt at multithreading under the hood somewhere in Numpy/Scipy (which doesn't work 
 here due to  repeated initializations of the Gaussian mixture model.) To fix this, the following
 environment variable is auto-set (hardcoded) before running:
@@ -178,26 +185,6 @@ To exit the tool, press `Ctrl-C` in your command line window as mentioned in
 the start-up instructions.
 
 
-### `strkit re-call`: Genotype re-caller
-
-This command has a similar feature-set as `strkit call`, but is designed to
-be used with the output of other long-read STR genotyping methods to refine
-the genotype estimates when calling from HiFi reads.\
-
-#### Features:
-
-* Support for re-calling output from `tandem-genotypes`, `RepeatHMM`, and `Straglr`
-* Strand resampling / bias correction (for use with the `tandem-genotypes` program)
-* 95% confidence intervals on calls via user-configurable bootstrapping
-
-#### Notes:
-
-* `--min-allele-reads` will affect the confidence intervals given by the bootstrap process,
-  especially in low-coverage loci. This should be set depending on the read technology being used;
-  something like a single PacBio HiFi read generally contains higher-quality information than a single
-  PacBio CLR read, for example.
-
-
 
 ### `strkit mi`: Mendelian inheritance analysis
 

{strkit-0.8.0a25 → strkit-0.8.1}/README.md

@@ -64,6 +64,7 @@ strkit call \
   --realign \  # If using PacBio HiFi reads, enable this to enable local realignment / read recovery
   --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) list of loci to genotype
+  --incorporate-snvs path/to/dbsnp.vcf.gz \   # If you want SNV calls to help phase STRs & speed up STRkit, include this
   --min-reads 4 \  # Minimum number of supporting reads needed to make a call
   --min-allele-reads 2 \  # Minimum number of supporting reads needed to call a specific allele size 
   --flank-size 70 \  # Size of the flanking region to use on either side of a region to properly anchor reads
@@ -75,14 +76,20 @@ PacBio provides a
 [recommended workflow](https://github.com/PacificBiosciences/apps-scripts/tree/master/RepeatAnalysisTools)
 for CCS alignment in this scenario.
 
-If you're using HiFi reads as input, **use the `--hq` and `--realign` options** to get better genotype calculation
-and a greater proportion of reads incorporated into the computed genotypes, respectively. 
-These should not add much performance overhead.
+If you're using HiFi reads as input, **use the `--hq` and `--realign` options** to get better 
+genotype calculation and a greater proportion of reads incorporated into the computed genotypes, 
+respectively. These should not add much performance overhead.
 
 If more than one read file is specified, the reads will be pooled. This can come in handy if you
 have e.g. multiple flow cells of the same sample split into different BAM files, or the reads are
 split by chromosome.
 
+If you want to incorporate SNV calling into the process, which speeds up runtime and gives
+marginally better calling results, you must provide an indexed, `bgzip`-compressed SNV catalog 
+VCF which matches your reference genome. You can find dbSNP VCFs at
+[`https://ftp.ncbi.nih.gov/snp/organisms/human_9606/VCF/`](https://ftp.ncbi.nih.gov/snp/organisms/human_9606/VCF/).
+The file for GRCh38 is called `00-common_all.vcf.gz` as of time of writing.
+
 If you want to output a full call report, you can use the `--json output-file.json` argument to
 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
@@ -101,7 +108,7 @@ samtools faidx my-reference.fa.gz  # Generates a .fai index file
 
 ##### Note on OpenMP Threading
 
-Slow performance can result from running `strkit call` or `strkit re-call` on a system with OpenMP, 
+Slow performance can result from running `strkit call` on a system with OpenMP, 
 due to a misguided  attempt at multithreading under the hood somewhere in Numpy/Scipy (which doesn't work 
 here due to  repeated initializations of the Gaussian mixture model.) To fix this, the following
 environment variable is auto-set (hardcoded) before running:
@@ -162,26 +169,6 @@ To exit the tool, press `Ctrl-C` in your command line window as mentioned in
 the start-up instructions.
 
 
-### `strkit re-call`: Genotype re-caller
-
-This command has a similar feature-set as `strkit call`, but is designed to
-be used with the output of other long-read STR genotyping methods to refine
-the genotype estimates when calling from HiFi reads.\
-
-#### Features:
-
-* Support for re-calling output from `tandem-genotypes`, `RepeatHMM`, and `Straglr`
-* Strand resampling / bias correction (for use with the `tandem-genotypes` program)
-* 95% confidence intervals on calls via user-configurable bootstrapping
-
-#### Notes:
-
-* `--min-allele-reads` will affect the confidence intervals given by the bootstrap process,
-  especially in low-coverage loci. This should be set depending on the read technology being used;
-  something like a single PacBio HiFi read generally contains higher-quality information than a single
-  PacBio CLR read, for example.
-
-
 
 ### `strkit mi`: Mendelian inheritance analysis
 

{strkit-0.8.0a25 → strkit-0.8.1}/setup.py

@@ -14,18 +14,18 @@ setup(
 
     python_requires="~=3.9",
     install_requires=[
-        "Flask>=2.2.2,<2.3",
-        "pysam>=0.19,<0.21",
-        "numpy>=1.23.4,<1.25",
+        "Flask>=2.2.5,<2.3",
+        "pysam>=0.19,<0.22",
+        "numpy>=1.23.4,<1.26",
         "parasail>=1.2.4,<1.4",
-        "scikit-learn>=1.2.1,<1.3",
+        "scikit-learn>=1.2.1,<1.4",
         "scipy>=1.10,<1.11",
-        "statsmodels>=0.13.5,<0.14",
+        "statsmodels>=0.14.0,<0.15",
     ],
     extras_require={
         "rustdeps": [
-            "orjson>=3.8.5,<3.9",
-            "strkit_rust_ext==0.3.0",
+            "orjson>=3.8.5,<4",
+            "strkit_rust_ext==0.4.0",
         ],
     },
 

strkit-0.8.1/strkit/VERSION

@@ -0,0 +1 @@
+0.8.1

{strkit-0.8.0a25 → strkit-0.8.1}/strkit/call/__init__.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
 from .allele import call_alleles
-from .caller import call_sample
-from .re_caller import re_call_all_alleles
+from .call_sample import call_sample
 
 __all__ = [
     "call_alleles",
     "call_sample",
-    "re_call_all_alleles",
 ]

{strkit-0.8.0a25 → strkit-0.8.1}/strkit/call/allele.py

@@ -20,6 +20,8 @@ from typing import Iterable, Literal, Optional, TypedDict, Union
 
 import strkit.constants as cc
 
+from .utils import get_new_seed
+
 __all__ = [
     "RepeatCounts",
     "CallDict",
@@ -27,7 +29,7 @@ __all__ = [
     "call_alleles",
 ]
 
-RepeatCounts = Union[list[int], tuple[int, ...], list[float], tuple[float, ...]]
+RepeatCounts = Union[list[int], tuple[int, ...], list[float], tuple[float, ...], NDArray[np.int_], NDArray[np.float_]]
 
 
 # K-means convergence errors - we expect convergence to some extent with homozygous alleles
@@ -90,6 +92,7 @@ def fit_gmm(
     n_components = n_alleles
     while n_components > 0:
         if n_components == 1:  # Don't need to do the full fit for a single peak, just calculate the parameters
+            # I've confirmed this gives an ~identical result to fitting a GMM with one parameter.
             fake_g: object = type("", (), {})()
             fake_g.means_ = np.array([[np.mean(sample_rs)]])
             fake_g.weights_ = np.array([[1.0]])
@@ -101,7 +104,7 @@ def fit_gmm(
             init_params=init_params,
             covariance_type="spherical",
             n_init=N_GM_INIT,
-            random_state=rng.integers(0, 4096).item(),
+            random_state=get_new_seed(rng),
         ).fit(sample_rs)
 
         # noinspection PyUnresolvedReferences
@@ -145,6 +148,11 @@ class CallDict(TypedDict):
     modal_n_peaks: 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 []))
+
+
 def call_alleles(
     repeats_fwd: RepeatCounts,
     repeats_rev: RepeatCounts,
@@ -169,10 +177,8 @@ def call_alleles(
     fwd_len = fwd_strand_reads.shape[0]
     rev_len = rev_strand_reads.shape[0]
 
-    fwd_strand_weights = np.array(
-        read_weights_fwd if read_weights_fwd is not None else np.array(([1/fwd_len] * fwd_len) if fwd_len else []))
-    rev_strand_weights = np.array(
-        read_weights_rev if read_weights_rev is not None else np.array(([1/rev_len] * rev_len) if rev_len else []))
+    fwd_strand_weights = make_read_weights(read_weights_fwd, fwd_len)
+    rev_strand_weights = make_read_weights(read_weights_rev, rev_len)
 
     assert fwd_strand_reads.shape == fwd_strand_weights.shape
     assert rev_strand_reads.shape == rev_strand_weights.shape

{strkit-0.8.0a25/strkit/call/caller → strkit-0.8.1/strkit/call}/call_locus.py

@@ -23,13 +23,14 @@ from .realign import realign_read
 from .repeats import get_repeat_count, get_ref_repeat_count
 from .snvs import (
     SNV_OUT_OF_RANGE_CHAR,
-    # get_read_snvs,
-    get_read_snvs_dbsnp,
+    get_candidate_snvs,
+    get_read_snvs,
+    # get_read_snvs_dbsnp,
     calculate_useful_snvs,
     call_and_filter_useful_snvs,
 )
-from .types import ReadDict, ReadDictExtra
-from .utils import find_pair_by_ref_pos, normalize_contig, round_to_base_pos
+from .types import ReadDict, ReadDictExtra, CandidateSNV
+from .utils import find_pair_by_ref_pos, normalize_contig, round_to_base_pos, get_new_seed
 
 
 __all__ = [
@@ -244,8 +245,70 @@ def calculate_read_distance(
     return distance_matrix
 
 
-def _get_new_seed(rng: np.random.Generator) -> int:
-    return rng.integers(0, 4096).item()
+def process_read_snvs_for_locus(
+    contig: str,
+    left_coord_adj: int,
+    right_coord_adj: int,
+    left_most_coord: int,
+    right_most_coord: int,
+    ref: FastaFile,
+    read_dict_items: tuple[tuple[str, ReadDict], ...],
+    read_dict_extra: dict[str, ReadDictExtra],
+    read_pairs: dict[str, list[tuple[int, int]]],
+    candidate_snvs_dict: dict[int, CandidateSNV],
+    only_known_snvs: bool,
+    logger_: logging.Logger,
+    locus_log_str: str,
+) -> set[int]:
+    # 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.
+
+    locus_snvs: set[int] = set()
+
+    ref_cache = ref.fetch(contig, left_most_coord, right_most_coord + 1).upper()
+
+    for rn, read in read_dict_items:
+        #   --> RE-ENABLE FOR DE NOVO SNV FINDER <--
+        scl = read_dict_extra[rn]["sig_clip_left"]
+        scr = read_dict_extra[rn]["sig_clip_right"]
+        if scl or scr:
+            logger_.debug(
+                f"{locus_log_str} - {rn} has significant clipping; trimming pairs by "
+                f"{significant_clip_snv_take_in} bp per side for SNV-finding")
+
+        snv_pairs = read_pairs[rn]
+
+        if len(snv_pairs) < (twox_takein := significant_clip_snv_take_in * 2):
+            logger_.warning(f"{locus_log_str} - skipping SNV calculation for '{rn}' (<{twox_takein} pairs)")
+            continue
+
+        if read_dict_extra[rn]["sig_clip_left"]:
+            snv_pairs = snv_pairs[significant_clip_snv_take_in:]
+        if read_dict_extra[rn]["sig_clip_right"]:
+            snv_pairs = snv_pairs[:-1 * significant_clip_snv_take_in]
+
+        # snv_pairs = list(filter(lambda p: p[1] in candidate_snvs_dict, snv_pairs))
+
+        #   --> RE-ENABLE FOR DE NOVO SNV FINDER <--
+        snvs = get_read_snvs(
+            read_dict_extra[rn]["_qs"],
+            snv_pairs,
+            ref_cache,
+            left_most_coord,
+            left_coord_adj,
+            right_coord_adj,
+        )
+        # snvs = get_read_snvs_dbsnp(
+        #     candidate_snvs_dict_items_flat,
+        #     read_dict_extra[rn]["_qs"],
+        #     read_pairs[rn],
+        #     left_coord_adj,
+        #     right_coord_adj,
+        # )
+        locus_snvs.update(filter(lambda p: (not only_known_snvs) or p in candidate_snvs_dict, snvs.keys()))
+        read_dict_extra[rn]["snv"] = snvs
+
+    return locus_snvs
 
 
 def call_alleles_with_incorporated_snvs(
@@ -259,6 +322,7 @@ def call_alleles_with_incorporated_snvs(
     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]],
+    candidate_snvs_dict: dict[int, CandidateSNV],
     rng: np.random.Generator,
     logger_: logging.Logger,
     locus_log_str: str,
@@ -390,7 +454,7 @@ def call_alleles_with_incorporated_snvs(
             gm_filter_factor=1,  # n_alleles=1, so this is ignored
             hq=hq,
             force_int=not fractional,
-            seed=_get_new_seed(rng),
+            seed=get_new_seed(rng),
             logger_=logger_,
             debug_str=f"{locus_log_str} a{ci}"
         )
@@ -412,8 +476,11 @@ def call_alleles_with_incorporated_snvs(
     # is an array of length 1.
 
     # Leaving this as an np.array(...) for type detect since #calls is low:
-    cdd_calls = np.array([x["call"][0] for x in cdd])
-    peak_order: NDArray[np.int_] = np.argsort(cdd_calls)  # To reorder call arrays in least-to-greatest by copy number
+    cdd_sort_order_determiner = np.array(
+        [(x["peaks"][0], x["call_95_cis"][0][0]) for x in cdd],
+        dtype=[("p", np.float_), ("i", np.float_ if fractional else np.int_)])
+    # To reorder call arrays in least-to-greatest by raw peak mean, and then by 95% CI left boundary:
+    peak_order: NDArray[np.int_] = np.argsort(cdd_sort_order_determiner, order=("p", "i"))
 
     # Re-order the call data dictionary, now that we've established an ordering
     # noinspection PyTypeChecker
@@ -432,7 +499,7 @@ def call_alleles_with_incorporated_snvs(
 
     # All call_datas are truth-y; all arrays should be ordered by peak_order
     call_data = {
-        "call": cdd_calls[peak_order],
+        "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),
         "peaks": np.concatenate(tuple(cc["peaks"] for cc in cdd_ordered), axis=None),
@@ -446,7 +513,7 @@ def call_alleles_with_incorporated_snvs(
 
     # Called useful SNVs to add to the final return dictionary:
     called_useful_snvs: list[dict] = call_and_filter_useful_snvs(
-        n_alleles, read_dict, useful_snvs, locus_log_str, logger_)
+        n_alleles, read_dict, useful_snvs, candidate_snvs_dict, locus_log_str, logger_)
 
     if not called_useful_snvs:  # No useful SNVs left, so revert to "dist" assignment method
         return "dist", None
@@ -454,23 +521,6 @@ def call_alleles_with_incorporated_snvs(
     return assign_method, (call_data, called_useful_snvs)
 
 
-def _human_chrom_to_refseq_accession(contig: str, snv_vcf_contigs: tuple[str, ...]) -> Optional[str]:
-    contig = contig.removeprefix("chr")
-    if contig == "X":
-        contig = "23"
-    if contig == "Y":
-        contig = "24"
-    if contig == "M":
-        contig = "12920"
-    contig = f"NC_{contig.zfill(6)}"
-
-    for vcf_contig in snv_vcf_contigs:
-        if vcf_contig.startswith(contig):
-            return vcf_contig
-
-    return None
-
-
 def call_locus(
     t_idx: int,
     t: tuple,
@@ -530,6 +580,7 @@ def call_locus(
     # and polyploidy is hard.
     # should_incorporate_snvs: bool = incorporate_snvs and n_alleles == 2
     should_incorporate_snvs: bool = snv_vcf_file is not None and n_alleles == 2
+    only_known_snvs: bool = True  # TODO: parametrize
 
     try:
         ref_left_flank_seq = ref.fetch(ref_contig, left_flank_coord, left_coord)
@@ -555,7 +606,7 @@ def call_locus(
         return None
 
     # String representation of locus for logging purposes
-    locus_log_str: str = f"{sample_id + ' ' if sample_id else ''}locus {t_idx}: {contig}:{left_coord}-{right_coord}"
+    locus_log_str: str = f"{sample_id}{' ' if sample_id else ''}locus {t_idx}: {contig}:{left_coord}-{right_coord}"
 
     # Get reference repeat count by our method, so we can calculate offsets from reference
     ref_cn: Union[int, float]
@@ -593,18 +644,11 @@ def call_locus(
 
     # Find candidate SNVs, if we're using SNV data
 
-    candidate_snvs: list[tuple[str, int, Optional[str], tuple[str, ...]]] = []
-    if should_incorporate_snvs and snv_vcf_file:
-        snv_contig: str = contig
-        if snv_contig not in snv_vcf_contigs:
-            if snv_vcf_file_format == "num":
-                snv_contig = snv_contig.removeprefix("chr")
-            elif snv_vcf_file_format == "acc":
-                snv_contig = _human_chrom_to_refseq_accession(snv_contig, snv_vcf_contigs)
-            # Otherwise, leave as-is
-
-        for snv in snv_vcf_file.fetch(snv_contig, left_most_coord, right_most_coord + 1):
-            candidate_snvs.append((snv.id, snv.pos, snv.ref, snv.alts or ()))
+    candidate_snvs_dict: dict[int, CandidateSNV] = {}  # Lookup dictionary for candidate SNVs by position
+    if n_overlapping_reads and should_incorporate_snvs and snv_vcf_file:
+        # ^^ n_overlapping_reads check since otherwise we will have invalid left/right_most_coord
+        candidate_snvs_dict = get_candidate_snvs(
+            snv_vcf_file, snv_vcf_contigs, snv_vcf_file_format, contig, left_most_coord, right_most_coord)
 
     # Build the read dictionary with segment information, copy number, weight, & more. ---------------------------------
 
@@ -614,8 +658,6 @@ def call_locus(
 
     # Aggregations for additional read-level data
     read_kmers: Counter[str] = Counter()
-    locus_snvs: set[int] = set()
-
     read_pairs: dict[str, list[tuple[int, int]]] = {}
 
     # Keep track of left-most and right-most coordinates
@@ -660,7 +702,7 @@ def call_locus(
             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_left_flank_seq + ref_seq + ref_right_flank_seq_plus_1,  # TODO: plus 1, really?
+                ref_seq=f"{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,
@@ -790,13 +832,13 @@ def call_locus(
             # Observed significant increase in annoying, probably false SNVs near the edges of significantly
             # clipped reads in CCS data. Figure out if we have large clipping for later use here in the SNV finder.
             #   --> RE-ENABLE FOR DE NOVO SNV FINDER <--
-            # cigar_first_op = segment.cigartuples[0]
-            # cigar_last_op = segment.cigartuples[-1]
-            #
-            # read_dict_extra[rn]["sig_clip_left"] = (
-            #     cigar_first_op[0] in (4, 5) and cigar_first_op[1] >= significant_clip_threshold)
-            # read_dict_extra[rn]["sig_clip_right"] = (
-            #         cigar_last_op[0] in (4, 5) and cigar_last_op[1] >= significant_clip_threshold)
+            cigar_first_op = segment.cigartuples[0]
+            cigar_last_op = segment.cigartuples[-1]
+
+            read_dict_extra[rn]["sig_clip_left"] = (
+                cigar_first_op[0] in (4, 5) and cigar_first_op[1] >= significant_clip_threshold)
+            read_dict_extra[rn]["sig_clip_right"] = (
+                    cigar_last_op[0] in (4, 5) and cigar_last_op[1] >= significant_clip_threshold)
 
             # Cache aligned pairs, since it takes a lot of time to extract, and we use it for calculate_useful_snvs
             read_pairs[rn] = pairs
@@ -860,50 +902,13 @@ def call_locus(
     elif should_incorporate_snvs and n_reads_in_dict >= min_snv_read_coverage and not have_rare_realigns:
         # LIMITATION: Currently can only use SNVs for haplotyping with haploid/diploid
 
-        # 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()
+        # Second read loop occurs in this function
+        locus_snvs: set[int] = process_read_snvs_for_locus(
+            contig, left_coord_adj, right_coord_adj, left_most_coord, right_most_coord, ref, read_dict_items,
+            read_dict_extra, read_pairs, candidate_snvs_dict, only_known_snvs, logger_, locus_log_str)
 
-        for rn, read in read_dict_items:
-            #   --> RE-ENABLE FOR DE NOVO SNV FINDER <--
-            # scl = read_dict_extra[rn]["sig_clip_left"]
-            # scr = read_dict_extra[rn]["sig_clip_right"]
-            # if scl or scr:
-            #     logger_.debug(
-            #         f"{locus_log_str} - {rn} has significant clipping; trimming pairs by "
-            #         f"{significant_clip_snv_take_in} bp per side for SNV-finding")
-            #
-            # snv_pairs = read_pairs[rn]
-            #
-            # if len(snv_pairs) < (twox_takein := significant_clip_snv_take_in * 2):
-            #     logger_.warning(f"{locus_log_str} - skipping SNV calculation for '{rn}' (<{twox_takein} pairs)")
-            #     continue
-            #
-            # if read_dict_extra[rn]["sig_clip_left"]:
-            #     snv_pairs = snv_pairs[significant_clip_snv_take_in:]
-            # if read_dict_extra[rn]["sig_clip_right"]:
-            #     snv_pairs = snv_pairs[:-1*significant_clip_snv_take_in]
-
-            #   --> RE-ENABLE FOR DE NOVO SNV FINDER <--
-            # snvs = get_read_snvs(
-            #     contig,
-            #     read_dict_extra[rn]["_qs"],
-            #     snv_pairs,
-            #     ref_cache,
-            #     left_most_coord,
-            #     left_coord_adj,
-            #     right_coord_adj,
-            # )
-            snvs = get_read_snvs_dbsnp(
-                candidate_snvs, read_dict_extra[rn]["_qs"], read_pairs[rn], left_coord_adj, right_coord_adj)
-            locus_snvs.update(snvs.keys())
-            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_items, read_dict_extra, read_pairs, locus_snvs))
+        useful_snvs: list[tuple[int, int]] = calculate_useful_snvs(
+            n_reads_in_dict, read_dict_items, read_dict_extra, read_pairs, locus_snvs, min_allele_reads)
         n_useful_snvs: int = len(useful_snvs)
 
         if not n_useful_snvs:
@@ -920,6 +925,7 @@ def call_locus(
                 read_dict_extra=read_dict_extra,
                 n_reads_in_dict=n_reads_in_dict,
                 useful_snvs=useful_snvs,
+                candidate_snvs_dict=candidate_snvs_dict,
                 rng=rng,
                 logger_=logger_,
                 locus_log_str=locus_log_str,
@@ -929,25 +935,6 @@ def call_locus(
                 call_data = call_res[0]  # Call data dictionary
                 call_dict_base["snvs"] = call_res[1]  # Called useful SNVs
 
-        # TODO:
-        #  - use reads with at least 1 SNPs called to separate 'training reads'
-        #  - eliminate 1-SNV reads with a unique haplotype vs any non-1-SNP reads... or something like that.
-        #    (see m64012_190920_173625/31917565/ccs)
-        #  - then, assign all reads - either based on what group they 'trained' or (for no SNP call ones)
-        #    based on the GMMs (maybe some kind of certainty of assignment???)
-
-        # TODO:
-        #  - maybe 3 approaches:
-        #    - if not enough SNV info / almost no reads have it, just do old method.
-        #    - if we have some SNV info for all reads AND it's not a single read count (perfectly homozygous)
-        #      (how to quantify?), do distance-based with read copy numbers AND SNV data - e.g. if we have just 1 SNP
-        #    - if we have LOTS of SNV data for the majority of reads, do assignment just using SNV data and assign
-        #      reads to peaks after (random assignment if equal chance of both groups)
-        #    - if we have COMPLETE SNV data (4+ for every read) we can do phasing + peak assignment just with SNVs
-        #      and just call the Gaussians from the separated reads (even just calculate stdev + mean for each bootstrap
-        #      iteration, which might save us some time...).
-        #    - keep track of which option as 'peak_calling_method' (pcm) or something
-
     elif n_reads_in_dict < min_snv_read_coverage:
         logger_.debug(
             f"{locus_log_str} - not enough coverage for SNV incorporation "
@@ -975,7 +962,7 @@ def call_locus(
             gm_filter_factor=3,  # TODO: parametrize
             hq=hq,
             force_int=not fractional,
-            seed=_get_new_seed(rng),
+            seed=get_new_seed(rng),
             logger_=logger_,
             debug_str=locus_log_str,
         ) or {}  # Still false-y

{strkit-0.8.0a25/strkit/call/caller → strkit-0.8.1/strkit/call}/call_sample.py

@@ -25,6 +25,7 @@ from strkit.logger import logger
 
 from .call_locus import call_locus
 from .non_daemonic_pool import NonDaemonicPool
+from .utils import get_new_seed
 
 __all__ = [
     "call_sample",
@@ -251,7 +252,7 @@ def call_sample(
         # We use locus-specific random seeds for replicability, no matter which order
         # the loci are yanked out of the queue / how many processes we have.
         # Tuple of (1-indexed locus index, locus data, locus-specific random seed)
-        locus_queue.put((t_idx, t, rng.integers(0, 4096).item()))
+        locus_queue.put((t_idx, t, get_new_seed(rng)))
         contig_set.add(t[0])
         num_loci += 1
 
@@ -274,7 +275,7 @@ def call_sample(
         "realign": realign,
         "hq": hq,
         # "incorporate_snvs": incorporate_snvs,
-        "snv_vcf": str(snv_vcf),
+        "snv_vcf": str(snv_vcf) if snv_vcf else None,
         "targeted": targeted,
         "fractional": fractional,
         "respect_ref": respect_ref,