strkit 0.11.8__tar.gz → 0.12.0a1__tar.gz

{strkit-0.11.8/strkit.egg-info → strkit-0.12.0a1}/PKG-INFO

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

strkit-0.12.0a1/strkit/VERSION

@@ -0,0 +1 @@
+0.12.0a1

{strkit-0.11.8 → strkit-0.12.0a1}/strkit/constants.py

@@ -3,11 +3,8 @@ __all__ = [
     "CALLER_HIPSTR",
     "CALLER_GANGSTR",
     "CALLER_REPEATHMM",
-    "CALLER_REPEATHMM_RECALL",
     "CALLER_STRAGLR",
-    "CALLER_STRAGLR_RECALL",
     "CALLER_TANDEM_GENOTYPES",
-    "CALLER_TANDEM_GENOTYPES_RECALL",
     "CALL_SUPPORTED_CALLERS",
 
     "M_CHROMOSOME_NAMES",
@@ -24,13 +21,10 @@ CALLER_EXPANSIONHUNTER = "expansionhunter"
 CALLER_HIPSTR = "hipstr"
 CALLER_GANGSTR = "gangstr"
 CALLER_REPEATHMM = "repeathmm"
-CALLER_REPEATHMM_RECALL = "repeathmm-recall"
 CALLER_STRAGLR = "straglr"
-CALLER_STRAGLR_RECALL = "straglr-recall"
 CALLER_STRKIT = "strkit"
 CALLER_STRKIT_JSON = "strkit-json"
 CALLER_TANDEM_GENOTYPES = "tandem-genotypes"
-CALLER_TANDEM_GENOTYPES_RECALL = "tandem-genotypes-recall"
 
 CALL_SUPPORTED_CALLERS = (
     CALLER_REPEATHMM,
@@ -57,16 +51,9 @@ CHROMOSOMES = (
 MI_CALLERS = (
     CALLER_EXPANSIONHUNTER,
     CALLER_GANGSTR,
-    "generic-vcf",
-    "hipstr",
-    "lobstr",
-    "pacmonstr",
     CALLER_REPEATHMM,
-    CALLER_REPEATHMM_RECALL,
     CALLER_STRAGLR,
-    CALLER_STRAGLR_RECALL,
     CALLER_STRKIT,
     CALLER_STRKIT_JSON,
     CALLER_TANDEM_GENOTYPES,
-    CALLER_TANDEM_GENOTYPES_RECALL,
 )

{strkit-0.11.8 → strkit-0.12.0a1}/strkit/entry.py

@@ -364,28 +364,25 @@ def _exec_mi(p_args) -> None:
     from strkit.mi.base import BaseCalculator
     from strkit.mi.expansionhunter import ExpansionHunterCalculator
     from strkit.mi.gangstr import GangSTRCalculator
-    from strkit.mi.repeathmm import RepeatHMMCalculator, RepeatHMMReCallCalculator
-    from strkit.mi.straglr import StraglrCalculator, StraglrReCallCalculator
+    from strkit.mi.repeathmm import RepeatHMMCalculator
+    from strkit.mi.straglr import StraglrCalculator
     from strkit.mi.strkit import StrKitCalculator, StrKitJSONCalculator
-    from strkit.mi.tandem_genotypes import TandemGenotypesCalculator, TandemGenotypesReCallCalculator
+    from strkit.mi.tandem_genotypes import TandemGenotypesCalculator
 
     calc_classes: dict[str, Type[BaseCalculator]] = {
         c.CALLER_EXPANSIONHUNTER: ExpansionHunterCalculator,
         c.CALLER_GANGSTR: GangSTRCalculator,
         c.CALLER_REPEATHMM: RepeatHMMCalculator,
-        c.CALLER_REPEATHMM_RECALL: RepeatHMMReCallCalculator,
         c.CALLER_STRAGLR: StraglrCalculator,
-        c.CALLER_STRAGLR_RECALL: StraglrReCallCalculator,
         c.CALLER_STRKIT: StrKitCalculator,
         c.CALLER_STRKIT_JSON: StrKitJSONCalculator,
         c.CALLER_TANDEM_GENOTYPES: TandemGenotypesCalculator,
-        c.CALLER_TANDEM_GENOTYPES_RECALL: TandemGenotypesReCallCalculator,
     }
 
     caller = p_args.caller.lower()
 
     trf_bed_file = getattr(p_args, "trf_bed") or None
-    if trf_bed_file is None and caller in (c.CALLER_STRAGLR, c.CALLER_STRAGLR_RECALL):
+    if trf_bed_file is None and caller == c.CALLER_STRAGLR:
         raise ParamError("Using `strkit mi` with Straglr requires that the --trf-bed flag is used.")
 
     exclude_bed_file = p_args.exclude_loci_bed or None

strkit-0.12.0a1/strkit/mi/repeathmm.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from .base import BaseCalculator
+from .result import MIContigResult, MILocusData
+from ..utils import int_tuple
+
+__all__ = [
+    "RepeatHMMCalculator",
+]
+
+
+class RepeatHMMCalculator(BaseCalculator):
+    @staticmethod
+    def get_contigs_from_fh(fh) -> set:
+        return {ls[0] for ls in (line.split(":") for line in fh)}
+
+    @staticmethod
+    def make_calls_dict(ph, contig):
+        return {
+            tuple(k.split(":")): int_tuple(v.split("/"))
+            for k, v in (pv.split() for pv in ph)
+            if k.split(":")[0] == contig
+        }
+
+    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
+        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
+                open(self._child_call_file, "r") as cvf:
+
+            mc = self.get_contigs_from_fh(mvf)
+            fc = self.get_contigs_from_fh(fvf)
+            cc = self.get_contigs_from_fh(cvf)
+
+            return mc, fc, cc
+
+    def calculate_contig(self, contig: str) -> MIContigResult:
+        cr = MIContigResult()
+
+        with open(self._mother_call_file) as mh:
+            mother_calls = self.make_calls_dict(mh, contig)
+
+        with open(self._father_call_file) as fh:
+            father_calls = self.make_calls_dict(fh, contig)
+
+        with open(self._child_call_file) as ch:
+            for cv in ch:
+                locus_data, call = cv.strip().split(" ")
+                lookup = tuple(locus_data.split(":"))
+
+                if lookup[0] != contig:
+                    continue
+
+                bed_k = lookup[:3]
+
+                # Check to make sure call is present in TRF BED file, if it is specified
+                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
+                    continue
+
+                if self.should_exclude_locus(bed_k):
+                    continue
+
+                locus_start: int = int(lookup[1])
+                locus_end: int = int(lookup[2])
+
+                cr.seen_locus(contig, locus_start, locus_end)
+
+                # Check to make sure call is present in all trio individuals
+                if lookup not in mother_calls or lookup not in father_calls:
+                    continue
+
+                c_gt = int_tuple(call.split("/"))
+                m_gt = mother_calls[lookup]
+                f_gt = father_calls[lookup]
+
+                # Failed calls from RepeatHMM seem to be represented as 0/0, so skip this
+                # TODO… Need to decide if we actually want to include these?
+                #  or at least somehow record them
+                if (0, 0) in (c_gt, m_gt, f_gt):
+                    continue
+
+                # TODO: Include ref copies... should be in file somewhere?
+                cr.append(MILocusData(
+                    lookup[0],
+                    locus_start,
+                    locus_end,
+                    lookup[3],
+
+                    child_gt=int_tuple(call.split("/")),
+                    mother_gt=mother_calls[lookup],
+                    father_gt=father_calls[lookup],
+                ))
+
+        return cr

strkit-0.12.0a1/strkit/mi/straglr.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import BaseCalculator
+from .result import MILocusData, MIContigResult
+
+__all__ = [
+    "StraglrCalculator",
+]
+
+
+class StraglrCalculator(BaseCalculator):
+    @staticmethod
+    def get_contigs_from_fh(fh) -> set:
+        return {ls[0] for ls in (line.split("\t") for line in fh if not line.startswith("#"))}
+
+    def make_calls_dict(self, ph, contig, cr: Optional[MIContigResult] = None):
+        # For reference, dicts are ordered in Python 3.7+ (guaranteed)
+
+        calls = {}
+
+        for pv in ph:
+            if pv.startswith("#"):
+                continue
+
+            line = pv.strip().split("\t")
+
+            if line[0] != contig:
+                continue
+
+            locus = tuple(line[:3])
+
+            orig_motif = self._loci_dict.get(locus)
+            orig_motif = orig_motif[-1] if orig_motif else None
+
+            if not orig_motif:
+                continue
+
+            if self.should_exclude_locus(locus):
+                continue
+
+            if cr:
+                cr.seen_locus(locus[0], int(locus[1]), int(locus[2]))
+
+            # Transform the genotypes into something that is consistent across individuals,
+            # using the file with the list of loci.
+            gt_fact = len(line[3]) / len(orig_motif)
+
+            gt = tuple(float(g.split("(")[0]) * gt_fact for g in line[4].split(";"))
+            if len(gt) == 1:  # If it's homozygous, expand it out to length 2
+                gt = gt + gt
+
+            calls[locus + (orig_motif,)] = gt
+
+        return calls
+
+    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
+        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
+                open(self._child_call_file, "r") as cvf:
+
+            mc = self.get_contigs_from_fh(mvf)
+            fc = self.get_contigs_from_fh(fvf)
+            cc = self.get_contigs_from_fh(cvf)
+
+            return mc, fc, cc
+
+    def calculate_contig(self, contig: str):
+        cr = MIContigResult()
+
+        with open(self._mother_call_file, "r") as mh:
+            mother_calls = self.make_calls_dict(mh, contig)
+
+        with open(self._father_call_file, "r") as fh:
+            father_calls = self.make_calls_dict(fh, contig)
+
+        with open(self._child_call_file, "r") as ch:
+            child_calls = self.make_calls_dict(ch, contig, cr)
+
+        for locus_data, c_gt in child_calls.items():
+            # Check to make sure call is present in all trio individuals
+            if locus_data not in mother_calls or locus_data not in father_calls:
+                continue
+
+            cr.append(MILocusData(
+                contig=locus_data[0],
+                start=int(locus_data[1]),
+                end=int(locus_data[2]),
+                motif=locus_data[3],
+
+                child_gt=c_gt,
+                mother_gt=mother_calls[locus_data],
+                father_gt=father_calls[locus_data],
+
+                decimal=True,
+            ))
+
+        return cr

strkit-0.12.0a1/strkit/mi/tandem_genotypes.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from .base import BaseCalculator
+from .result import MIContigResult, MILocusData
+from ..utils import int_tuple
+
+__all__ = [
+    "TandemGenotypesCalculator",
+]
+
+
+class TandemGenotypesCalculator(BaseCalculator):
+    @staticmethod
+    def get_contigs_from_fh(fh) -> set[str]:
+        return {ls[0] for ls in (line.split("\t") for line in fh if not line.startswith("#"))}
+
+    @staticmethod
+    def make_calls_dict(ph, contig):
+        return {
+            tuple(line[:4]): int_tuple(line[6:8])
+            for line in (pv.strip().split("\t") for pv in ph if not pv.startswith("#"))
+            if line[0] == contig and "." not in line[6:8]
+        }
+
+    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
+        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
+                open(self._child_call_file, "r") as cvf:
+
+            mc = self.get_contigs_from_fh(mvf)
+            fc = self.get_contigs_from_fh(fvf)
+            cc = self.get_contigs_from_fh(cvf)
+
+            return mc, fc, cc
+
+    def calculate_contig(self, contig: str) -> MIContigResult:
+        cr = MIContigResult()
+
+        with open(self._mother_call_file) as mh:
+            mother_calls = self.make_calls_dict(mh, contig)
+
+        with open(self._father_call_file) as fh:
+            father_calls = self.make_calls_dict(fh, contig)
+
+        with open(self._child_call_file) as ch:
+            for cv in ch:
+                locus_data = cv.strip().split("\t")
+                lookup = tuple(locus_data[:4])
+
+                if locus_data[0] != contig:
+                    continue
+
+                bed_k = lookup[:3]
+
+                # Check to make sure call is present in TRF BED file, if it is specified
+                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
+                    continue
+
+                # noinspection PyTypeChecker
+                if self.should_exclude_locus(bed_k):
+                    continue
+
+                locus_start = int(lookup[1])
+                locus_end = int(lookup[2])
+
+                cr.seen_locus(contig, locus_start, locus_end)
+
+                # Check to make sure call is present in all trio individuals
+                if lookup not in mother_calls or lookup not in father_calls:
+                    continue
+
+                child_calls = locus_data[6:8]
+
+                if "." in child_calls:
+                    # Failed call
+                    continue
+
+                cr.append(MILocusData(
+                    contig=contig,
+                    start=locus_start,
+                    end=locus_end,
+                    motif=lookup[3],
+
+                    child_gt=int_tuple(child_calls),
+                    mother_gt=mother_calls[lookup],
+                    father_gt=father_calls[lookup],
+                ))
+
+        return cr

{strkit-0.11.8 → strkit-0.12.0a1/strkit.egg-info}/PKG-INFO

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

strkit-0.11.8/strkit/VERSION

@@ -1 +0,0 @@
-0.11.8

strkit-0.11.8/strkit/mi/repeathmm.py

@@ -1,192 +0,0 @@
-from __future__ import annotations
-
-from .base import BaseCalculator
-from .result import MIContigResult, MILocusData
-from ..utils import int_tuple, parse_cis
-
-__all__ = [
-    "RepeatHMMCalculator",
-    "RepeatHMMReCallCalculator",
-]
-
-
-class RepeatHMMCalculator(BaseCalculator):
-    @staticmethod
-    def get_contigs_from_fh(fh) -> set:
-        return {ls[0] for ls in (line.split(":") for line in fh)}
-
-    @staticmethod
-    def make_calls_dict(ph, contig):
-        return {
-            tuple(k.split(":")): int_tuple(v.split("/"))
-            for k, v in (pv.split() for pv in ph)
-            if k.split(":")[0] == contig
-        }
-
-    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
-        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
-                open(self._child_call_file, "r") as cvf:
-
-            mc = self.get_contigs_from_fh(mvf)
-            fc = self.get_contigs_from_fh(fvf)
-            cc = self.get_contigs_from_fh(cvf)
-
-            return mc, fc, cc
-
-    def calculate_contig(self, contig: str) -> MIContigResult:
-        cr = MIContigResult()
-
-        with open(self._mother_call_file) as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file) as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file) as ch:
-            for cv in ch:
-                locus_data, call = cv.strip().split(" ")
-                lookup = tuple(locus_data.split(":"))
-
-                if lookup[0] != contig:
-                    continue
-
-                bed_k = lookup[:3]
-
-                # Check to make sure call is present in TRF BED file, if it is specified
-                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
-                    continue
-
-                if self.should_exclude_locus(bed_k):
-                    continue
-
-                locus_start: int = int(lookup[1])
-                locus_end: int = int(lookup[2])
-
-                cr.seen_locus(contig, locus_start, locus_end)
-
-                # Check to make sure call is present in all trio individuals
-                if lookup not in mother_calls or lookup not in father_calls:
-                    continue
-
-                c_gt = int_tuple(call.split("/"))
-                m_gt = mother_calls[lookup]
-                f_gt = father_calls[lookup]
-
-                # Failed calls from RepeatHMM seem to be represented as 0/0, so skip this
-                # TODO… Need to decide if we actually want to include these?
-                #  or at least somehow record them
-                if (0, 0) in (c_gt, m_gt, f_gt):
-                    continue
-
-                # TODO: Include ref copies... should be in file somewhere?
-                cr.append(MILocusData(
-                    lookup[0],
-                    locus_start,
-                    locus_end,
-                    lookup[3],
-
-                    child_gt=int_tuple(call.split("/")),
-                    mother_gt=mother_calls[lookup],
-                    father_gt=father_calls[lookup],
-                ))
-
-        return cr
-
-
-class RepeatHMMReCallCalculator(RepeatHMMCalculator):
-    @staticmethod
-    def make_calls_dict(ph, contig):
-        return {
-            tuple(v[0].split(":")): (
-                int_tuple(v[1:3]),
-                parse_cis(v[3:5], commas=True),
-                parse_cis(v[5:7], commas=True),
-            )
-            for v in (pv.split("\t") for pv in ph)
-            if v[0].split(":")[0] == contig and "." not in v[1:3]
-        }
-
-    # TODO: Deduplicate with above
-    def calculate_contig(self, contig: str) -> MIContigResult:
-        cr = MIContigResult(includes_95_ci=True, includes_99_ci=True)
-
-        with open(self._mother_call_file) as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file) as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file) as ch:
-            for cv in ch:
-                locus_data = cv.strip().split("\t")
-                lookup = tuple(locus_data[0].split(":"))
-
-                if lookup[0] != contig:
-                    continue
-
-                bed_k = lookup[:3]
-
-                # Check to make sure call is present in TRF BED file, if it is specified
-                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
-                    continue
-
-                # noinspection PyTypeChecker
-                if self.should_exclude_locus(bed_k):
-                    continue
-
-                locus_start: int = int(lookup[1])
-                locus_end: int = int(lookup[2])
-
-                cr.seen_locus(contig, locus_start, locus_end)
-
-                # Check to make sure call is present in all trio individuals
-                if lookup not in mother_calls or lookup not in father_calls:
-                    continue
-
-                # TODO: What will failed calls look like here? Do we also check for 0?
-
-                m_gt, m_gt_95_ci, m_gt_99_ci = mother_calls[lookup]
-                f_gt, f_gt_95_ci, f_gt_99_ci = father_calls[lookup]
-
-                # print(m_gt, m_gt_95_ci, m_gt_99_ci)
-
-                calls = locus_data[1:3]
-
-                if "." in calls:
-                    # Failed call
-                    continue
-
-                c_gt = int_tuple(calls)
-                c_gt_95_ci = parse_cis(locus_data[3:5], commas=True)
-                c_gt_99_ci = parse_cis(locus_data[5:7], commas=True)
-
-                if (0, 0) in (c_gt, m_gt, f_gt):  # TODO
-                    # Failed call
-                    continue
-
-                if self._debug:  # TODO: Real logging
-                    print(f"c_gt={c_gt} c_gt_95_ci={c_gt_95_ci}")
-                    print(f"m_gt={m_gt} m_gt_95_ci={m_gt_95_ci}")
-                    print(f"f_gt={f_gt} f_gt_95_ci={f_gt_95_ci}")
-
-                # TODO: Put ref # here, since we have it with the detail thing
-                cr.append(MILocusData(
-                    lookup[0],
-                    int(lookup[1]),
-                    int(lookup[2]),
-                    lookup[3],
-
-                    child_gt=int_tuple(calls),
-                    mother_gt=m_gt,
-                    father_gt=f_gt,
-
-                    child_gt_95_ci=c_gt_95_ci,
-                    mother_gt_95_ci=m_gt_95_ci,
-                    father_gt_95_ci=f_gt_95_ci,
-
-                    child_gt_99_ci=c_gt_99_ci,
-                    mother_gt_99_ci=m_gt_99_ci,
-                    father_gt_99_ci=f_gt_99_ci,
-                ))
-
-        return cr

strkit-0.11.8/strkit/mi/straglr.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional
-
-from .base import BaseCalculator
-from .result import MILocusData, MIContigResult
-
-__all__ = [
-    "StraglrCalculator",
-    "StraglrReCallCalculator",
-]
-
-
-class StraglrCalculator(BaseCalculator):
-    @staticmethod
-    def get_contigs_from_fh(fh) -> set:
-        return {ls[0] for ls in (line.split("\t") for line in fh if not line.startswith("#"))}
-
-    def make_calls_dict(self, ph, contig, cr: Optional[MIContigResult] = None):
-        # For reference, dicts are ordered in Python 3.7+ (guaranteed)
-
-        calls = {}
-
-        for pv in ph:
-            if pv.startswith("#"):
-                continue
-
-            line = pv.strip().split("\t")
-
-            if line[0] != contig:
-                continue
-
-            locus = tuple(line[:3])
-
-            orig_motif = self._loci_dict.get(locus)
-            orig_motif = orig_motif[-1] if orig_motif else None
-
-            if not orig_motif:
-                continue
-
-            if self.should_exclude_locus(locus):
-                continue
-
-            if cr:
-                cr.seen_locus(locus[0], int(locus[1]), int(locus[2]))
-
-            # Transform the genotypes into something that is consistent across individuals,
-            # using the file with the list of loci.
-            gt_fact = len(line[3]) / len(orig_motif)
-
-            gt = tuple(float(g.split("(")[0]) * gt_fact for g in line[4].split(";"))
-            if len(gt) == 1:  # If it's homozygous, expand it out to length 2
-                gt = gt + gt
-
-            calls[locus + (orig_motif,)] = gt
-
-        return calls
-
-    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
-        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
-                open(self._child_call_file, "r") as cvf:
-
-            mc = self.get_contigs_from_fh(mvf)
-            fc = self.get_contigs_from_fh(fvf)
-            cc = self.get_contigs_from_fh(cvf)
-
-            return mc, fc, cc
-
-    def calculate_contig(self, contig: str):
-        cr = MIContigResult()
-
-        with open(self._mother_call_file, "r") as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file, "r") as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file, "r") as ch:
-            child_calls = self.make_calls_dict(ch, contig, cr)
-
-        for locus_data, c_gt in child_calls.items():
-            # Check to make sure call is present in all trio individuals
-            if locus_data not in mother_calls or locus_data not in father_calls:
-                continue
-
-            cr.append(MILocusData(
-                contig=locus_data[0],
-                start=int(locus_data[1]),
-                end=int(locus_data[2]),
-                motif=locus_data[3],
-
-                child_gt=c_gt,
-                mother_gt=mother_calls[locus_data],
-                father_gt=father_calls[locus_data],
-
-                decimal=True,
-            ))
-
-        return cr
-
-
-class StraglrReCallCalculator(BaseCalculator):
-    @staticmethod
-    def get_contigs_from_fh(fh) -> set:
-        return {ls[0] for ls in (line.split("\t") for line in fh if not line.startswith("#"))}
-
-    def make_calls_dict(self, ph, contig, cr: Optional[MIContigResult] = None):
-        # For reference, dicts are ordered in Python 3.7+ (guaranteed)
-
-        calls = {}
-
-        for pv in ph:
-            if pv.startswith("#"):
-                continue
-
-            line = pv.strip().split("\t")
-
-            if line[0] != contig:
-                continue
-
-            locus = tuple(line[:3])
-            orig_motif = self._loci_dict.get(locus)
-            orig_motif = orig_motif[-1] if orig_motif else None
-            if not orig_motif:
-                continue
-
-            if self.should_exclude_locus(locus):
-                continue
-
-            if cr:
-                cr.seen_locus(contig, int(locus[1]), int(locus[2]))
-
-            if "." in line[6:8]:
-                continue
-
-            # Transform the genotypes into something that is consistent across individuals,
-            # using the file with the list of loci.
-            # Round it to the nearest first decimal place, since that is what Straglr calls.
-
-            gt_fact = len(line[3]) / len(orig_motif)
-
-            def _to_tenth(x: str):
-                return round(float(x) * gt_fact * 10) / 10
-
-            gt = tuple(map(_to_tenth, line[6:8]))
-            gt_95_ci = tuple(tuple(map(_to_tenth, ci.split(","))) for ci in line[8:10])
-            gt_99_ci = tuple(tuple(map(_to_tenth, ci.split(","))) for ci in line[10:12])
-
-            calls[locus + (orig_motif,)] = (gt, gt_95_ci, gt_99_ci)
-
-        return calls
-
-    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
-        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
-                open(self._child_call_file, "r") as cvf:
-
-            mc = self.get_contigs_from_fh(mvf)
-            fc = self.get_contigs_from_fh(fvf)
-            cc = self.get_contigs_from_fh(cvf)
-
-            return mc, fc, cc
-
-    def calculate_contig(self, contig: str):
-        cr = MIContigResult(includes_95_ci=True, includes_99_ci=True)
-
-        with open(self._mother_call_file) as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file) as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file) as ch:
-            child_calls = self.make_calls_dict(ch, contig, cr)
-
-        for locus_data, c_gt_and_cis in child_calls.items():
-            # Check to make sure call is present in all trio individuals
-            if locus_data not in mother_calls or locus_data not in father_calls:
-                continue
-
-            locus_start = int(locus_data[1])
-            locus_end = int(locus_data[2])
-
-            c_gt, c_gt_95_ci, c_gt_99_ci = c_gt_and_cis
-
-            m_gt, m_gt_95_ci, m_gt_99_ci = mother_calls[locus_data]
-            f_gt, f_gt_95_ci, f_gt_99_ci = father_calls[locus_data]
-
-            cr.append(MILocusData(
-                contig=locus_data[0],
-                start=locus_start,
-                end=locus_end,
-                motif=locus_data[3],
-
-                child_gt=c_gt, mother_gt=m_gt, father_gt=f_gt,
-                child_gt_95_ci=c_gt_95_ci, mother_gt_95_ci=m_gt_95_ci, father_gt_95_ci=f_gt_95_ci,
-                child_gt_99_ci=c_gt_99_ci, mother_gt_99_ci=m_gt_99_ci, father_gt_99_ci=f_gt_99_ci,
-
-                decimal=True,
-            ))
-
-        return cr

strkit-0.11.8/strkit/mi/tandem_genotypes.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-from .base import BaseCalculator
-from .result import MIContigResult, MILocusData
-from ..utils import int_tuple, parse_cis
-
-__all__ = [
-    "TandemGenotypesCalculator",
-    "TandemGenotypesReCallCalculator",
-]
-
-
-class TandemGenotypesCalculator(BaseCalculator):
-    @staticmethod
-    def get_contigs_from_fh(fh) -> set[str]:
-        return {ls[0] for ls in (line.split("\t") for line in fh if not line.startswith("#"))}
-
-    @staticmethod
-    def make_calls_dict(ph, contig):
-        return {
-            tuple(line[:4]): int_tuple(line[6:8]) if "." not in line[6:8] else (None, None)
-            for line in (pv.strip().split("\t") for pv in ph if not pv.startswith("#"))
-            if line[0] == contig
-        }
-
-    def _get_sample_contigs(self, include_sex_chromosomes: bool = False) -> tuple[set, set, set]:
-        with open(self._mother_call_file, "r") as mvf, open(self._father_call_file, "r") as fvf, \
-                open(self._child_call_file, "r") as cvf:
-
-            mc = self.get_contigs_from_fh(mvf)
-            fc = self.get_contigs_from_fh(fvf)
-            cc = self.get_contigs_from_fh(cvf)
-
-            return mc, fc, cc
-
-    def calculate_contig(self, contig: str) -> MIContigResult:
-        cr = MIContigResult()
-
-        with open(self._mother_call_file) as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file) as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file) as ch:
-            for cv in ch:
-                locus_data = cv.strip().split("\t")
-                lookup = tuple(locus_data[:4])
-
-                if locus_data[0] != contig:
-                    continue
-
-                bed_k = lookup[:3]
-
-                # Check to make sure call is present in TRF BED file, if it is specified
-                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
-                    continue
-
-                # noinspection PyTypeChecker
-                if self.should_exclude_locus(bed_k):
-                    continue
-
-                locus_start = int(lookup[1])
-                locus_end = int(lookup[2])
-
-                cr.seen_locus(contig, locus_start, locus_end)
-
-                # Check to make sure call is present in all trio individuals
-                if lookup not in mother_calls or lookup not in father_calls:
-                    continue
-
-                child_calls = locus_data[6:8]
-
-                if "." in child_calls:
-                    # Failed call
-                    continue
-
-                cr.append(MILocusData(
-                    contig=contig,
-                    start=locus_start,
-                    end=locus_end,
-                    motif=lookup[3],
-
-                    child_gt=int_tuple(child_calls),
-                    mother_gt=mother_calls[lookup],
-                    father_gt=father_calls[lookup],
-                ))
-
-        return cr
-
-
-class TandemGenotypesReCallCalculator(TandemGenotypesCalculator):
-    @staticmethod
-    def make_calls_dict(ph, contig):
-        return {
-            # Use relative indices because we may have the original calls lurking
-            tuple(line[:4]): (
-                int_tuple(line[-6:-4]),
-                parse_cis(line[-4:-2], commas=True),
-                parse_cis(line[-2:], commas=True),
-            )
-            for line in (pv.strip().split("\t") for pv in ph)
-            if line[0] == contig and "." not in line[-6:-4]
-        }
-
-    def calculate_contig(self, contig: str) -> MIContigResult:
-        cr = MIContigResult(includes_95_ci=True, includes_99_ci=True)
-
-        with open(self._mother_call_file) as mh:
-            mother_calls = self.make_calls_dict(mh, contig)
-
-        with open(self._father_call_file) as fh:
-            father_calls = self.make_calls_dict(fh, contig)
-
-        with open(self._child_call_file) as ch:
-            for cv in ch:
-                locus_data = cv.strip().split("\t")
-                lookup = tuple(locus_data[:4])
-
-                if locus_data[0] != contig:
-                    continue
-
-                bed_k = lookup[:3]
-
-                # Check to make sure call is present in TRF BED file, if it is specified
-                if self._loci_file and self._loci_dict and bed_k not in self._loci_dict:
-                    continue
-
-                # noinspection PyTypeChecker
-                if self.should_exclude_locus(bed_k):
-                    continue
-
-                locus_start = int(lookup[1])
-                locus_end = int(lookup[2])
-
-                cr.seen_locus(contig, locus_start, locus_end)
-
-                # Check to make sure call is present in all trio individuals
-                if lookup not in mother_calls or lookup not in father_calls:
-                    continue
-
-                m_gt, m_gt_95_ci, m_gt_99_ci = mother_calls[lookup]
-                f_gt, f_gt_95_ci, f_gt_99_ci = father_calls[lookup]
-
-                calls = locus_data[-6:-4]
-
-                if "." in calls:
-                    # Failed call
-                    continue
-
-                cr.append(MILocusData(
-                    contig=lookup[0],
-                    start=int(lookup[1]),
-                    end=int(lookup[2]),
-                    motif=lookup[3],
-
-                    child_gt=int_tuple(calls),
-                    mother_gt=m_gt,
-                    father_gt=f_gt,
-
-                    child_gt_95_ci=parse_cis(locus_data[-4:-2], commas=True),
-                    mother_gt_95_ci=m_gt_95_ci,
-                    father_gt_95_ci=f_gt_95_ci,
-
-                    child_gt_99_ci=parse_cis(locus_data[-2:], commas=True),
-                    mother_gt_99_ci=m_gt_99_ci,
-                    father_gt_99_ci=f_gt_99_ci,
-
-                    # TODO: ref count
-                ))
-
-        return cr